From f50ca479e050b83e6216bca54e13d2623d9b5336 Mon Sep 17 00:00:00 2001 From: SatoshiQaziMuhammed Date: Sun, 8 Nov 2026 21:35:35 +0400 Subject: [PATCH] Open .kurd sub-pages and a site's own 404; show a suspended name as suspended (#40) * Open a .kurd page address typed with a path Tapping the address bar puts the page's full address in the search box, for example https://dks-news.kurd/kategori/ekonomi. The search only knew a bare name, and a .kurd address is never a web address or a search, so such input produced no result at all: the reader could not open, edit or reload any page below the home page. KurdName.parseAddress takes the name and the path, query and fragment after it (printable ASCII, no port or user info), and the .kurd row opens that page. The look-alike check still runs on the name; choosing the official name opens its home page, since the typed path belongs to the other site. * Show a .kurd site's own 404 page for a page it does not have A missing page was answered with 404 and an empty body. WebView replaces such a response with its own "Webpage not available" screen (ERR_HTTP_RESPONSE_CODE_FAILURE), as if the site could not be reached, although the gateway had proven the page absent from a site that loads. For the page's own document the server now serves the site's /404.html with status 404, as a web server does (dks.news ships one), and a line of text when the site has none. Missing images and scripts are answered as before. The fixture is a Kubo-built directory with index.html and 404.html. * Show a suspended .kurd name as suspended, and open nothing of it The register can now stop a name: the court for up to 30 days, the emergency council for 72 hours. The lookup reads Navnisan::Suspensions beside Names, at the same finalized block and through the same proof path, and applies the pallet's rule: a suspension of the name, or of a name it sits under as a subname, for the registration it was made against and not yet run out. A suspended name resolves to a new Suspended result however it was read, since a refusal needs no proof. The site server serves nothing (451) and the browser shows the existing notice with a pause icon, who stopped the name, until when, and the hash of the written reasons. Strings in English, Kurmanji and Turkish. A chain without the Suspensions item stores nothing there, so on today's runtime nothing changes. --- .../main/res/drawable/ic_kurd_suspended.xml | 13 +++ common/src/main/res/values-ku/strings.xml | 8 ++ common/src/main/res/values-tr/strings.xml | 8 ++ common/src/main/res/values/strings.xml | 8 ++ .../domain/search/DappSearchResult.kt | 9 +- .../domain/search/SearchDappInteractor.kt | 6 +- .../browser/main/DAppBrowserFragment.kt | 34 +++++++ .../browser/main/kurd/KurdPageUi.kt | 7 +- .../search/DAppSearchViewModel.kt | 16 ++-- .../src/main/res/layout/view_kurd_notice.xml | 80 ++++++++++++++++ .../domain/search/SearchDappInteractorTest.kt | 7 ++ .../browser/main/kurd/KurdPageUiTest.kt | 10 ++ .../nova/runtime/names/KurdName.kt | 22 +++++ .../nova/runtime/names/KurdNameResolver.kt | 2 + .../nova/runtime/names/KurdResolution.kt | 6 ++ .../nova/runtime/names/NameLookup.kt | 29 +++++- .../nova/runtime/names/NameSuspension.kt | 46 ++++++++++ .../runtime/names/content/KurdSiteServer.kt | 25 ++++- .../nova/runtime/names/KurdNameTest.kt | 24 +++++ .../runtime/names/KurdResolutionJudgeTest.kt | 13 +++ .../nova/runtime/names/NameLookupTest.kt | 86 ++++++++++++++++++ .../names/content/KurdSiteServerTest.kt | 34 +++++++ .../src/test/resources/kurd-content/README.md | 4 + .../resources/kurd-content/site-with-404.car | Bin 0 -> 355 bytes 24 files changed, 476 insertions(+), 21 deletions(-) create mode 100644 common/src/main/res/drawable/ic_kurd_suspended.xml create mode 100644 runtime/src/main/java/io/novafoundation/nova/runtime/names/NameSuspension.kt create mode 100644 runtime/src/test/resources/kurd-content/site-with-404.car diff --git a/common/src/main/res/drawable/ic_kurd_suspended.xml b/common/src/main/res/drawable/ic_kurd_suspended.xml new file mode 100644 index 00000000..0d11dd56 --- /dev/null +++ b/common/src/main/res/drawable/ic_kurd_suspended.xml @@ -0,0 +1,13 @@ + + + + + diff --git a/common/src/main/res/values-ku/strings.xml b/common/src/main/res/values-ku/strings.xml index b1fc82d1..29d73cf6 100644 --- a/common/src/main/res/values-ku/strings.xml +++ b/common/src/main/res/values-ku/strings.xml @@ -2142,6 +2142,14 @@ Dîsa jî veke Navekî wiha tune ye %s ne tomarkirî ye, an jî dema wê qediyaye. + Ev nav hatiye rawestandin + Dîwanê ev nav heta %s rawestandiye. Heta wê demê malpera wê nayê vekirin. + Desteya awarte ev nav heta %s rawestandiye. Ev rawestandin bi xwe diqede; Dîwan dikare wê zûtir rake. + Biryar + Heta + Hincet + Dîwan + Desteya awarte Li ser vî navî malper tune Nav tomarkirî ye, lê xwediyê wê malperek ku cîzdan dikare veke belav nekiriye. Nehat barkirin diff --git a/common/src/main/res/values-tr/strings.xml b/common/src/main/res/values-tr/strings.xml index 55bd6b24..0e29910f 100644 --- a/common/src/main/res/values-tr/strings.xml +++ b/common/src/main/res/values-tr/strings.xml @@ -2139,6 +2139,14 @@ Referral kısmına bu adresi yapıştır: Yine de aç Böyle bir ad yok %s kayıtlı değil ya da kaydının süresi doldu. + Bu ad askıya alındı + Dîwan bu adı %s tarihine kadar askıya aldı. O zamana kadar sitesi açılamaz. + Acil kurul bu adı %s tarihine kadar askıya aldı. Askı kendiliğinden biter; Dîwan daha önce kaldırabilir. + Karar + Bitiş + Gerekçe + Dîwan + Acil kurul Bu adda site yok Ad kayıtlı, ama sahibi cüzdanın açabileceği bir site yayımlamamış. Yüklenemedi diff --git a/common/src/main/res/values/strings.xml b/common/src/main/res/values/strings.xml index 46fde249..835edf8e 100644 --- a/common/src/main/res/values/strings.xml +++ b/common/src/main/res/values/strings.xml @@ -2867,6 +2867,14 @@ Open anyway No such name %s is not registered, or its registration has ended. + This name is suspended + The Dîwan has suspended this name until %s. Its site cannot be opened until then. + The emergency council has suspended this name until %s. It ends by itself; the Dîwan can lift it sooner. + Decided by + Until + Reasons + Dîwan + Emergency council No site at this name The name is registered, but its owner has not published a site the wallet can open. Could not be loaded diff --git a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/DappSearchResult.kt b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/DappSearchResult.kt index 8c36943c..fa28e0ce 100644 --- a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/DappSearchResult.kt +++ b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/DappSearchResult.kt @@ -12,11 +12,14 @@ sealed interface DappSearchResult { override val isTrustedByNova: Boolean = false } - /** A `.kurd` name: resolved on chain when opened, never looked up on the web. */ - class KurdName(val name: io.novafoundation.nova.runtime.names.KurdName) : DappSearchResult { + /** A page under a `.kurd` name: resolved on chain when opened, never looked up on the web. */ + class KurdName( + val name: io.novafoundation.nova.runtime.names.KurdName, + val path: String = "/" + ) : DappSearchResult { override val isTrustedByNova: Boolean = true - val url: String get() = "https://${name.name}/" + val url: String get() = "https://${name.name}$path" } class Dapp(val dapp: DApp) : DappSearchResult { diff --git a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/SearchDappInteractor.kt b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/SearchDappInteractor.kt index 423a827e..15aa8795 100644 --- a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/SearchDappInteractor.kt +++ b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/domain/search/SearchDappInteractor.kt @@ -34,7 +34,7 @@ class SearchDappInteractor( .map(DappSearchResult::Dapp) // A .kurd name is resolved on chain by the wallet: never a web address, never a search query - val kurdName = KurdName.parse(query).takeIf { KurdName.mentionsKurd(query) } + val kurdAddress = KurdName.parseAddress(query).takeIf { KurdName.mentionsKurd(query) } val searchGroupContent = when { query.isEmpty() -> null @@ -50,8 +50,8 @@ class SearchDappInteractor( } buildMap { - kurdName?.let { - put(DappSearchGroup.KURD_NAME, listOf(DappSearchResult.KurdName(it))) + kurdAddress?.let { (name, path) -> + put(DappSearchGroup.KURD_NAME, listOf(DappSearchResult.KurdName(name, path))) } searchGroupContent?.let { diff --git a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/DAppBrowserFragment.kt b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/DAppBrowserFragment.kt index d4424871..68dafec3 100644 --- a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/DAppBrowserFragment.kt +++ b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/DAppBrowserFragment.kt @@ -26,6 +26,7 @@ import io.novafoundation.nova.common.utils.insets.applyNavigationBarInsets import io.novafoundation.nova.common.utils.insets.applyStatusBarInsets import io.novafoundation.nova.common.utils.makeGone import io.novafoundation.nova.common.utils.makeVisible +import io.novafoundation.nova.common.utils.formatting.formatDateTime import io.novafoundation.nova.common.utils.setImageTintRes import io.novafoundation.nova.common.utils.setVisible import io.novafoundation.nova.common.utils.webView.WebViewRequestInterceptor @@ -51,6 +52,7 @@ import io.novafoundation.nova.feature_dapp_impl.web3.webview.Web3WebViewClient import io.novafoundation.nova.feature_dapp_impl.web3.webview.WebViewHolder import io.novafoundation.nova.feature_external_sign_api.presentation.externalSign.AuthorizeDappBottomSheet import io.novafoundation.nova.runtime.names.KurdName +import io.novafoundation.nova.runtime.names.NameSuspension import javax.inject.Inject import kotlinx.coroutines.Job import kotlinx.coroutines.launch @@ -445,6 +447,22 @@ class DAppBrowserFragment : BaseFragment { + val suspension = requireNotNull(page.suspension) { "A suspended notice without its suspension" } + val until = suspension.until.formatDateTime() + val message = when (suspension.by) { + NameSuspension.By.COURT -> R.string.dapp_kurd_suspended_court_message + NameSuspension.By.EMERGENCY -> R.string.dapp_kurd_suspended_emergency_message + } + Look( + R.drawable.ic_kurd_suspended, + R.color.icon_negative, + R.string.dapp_kurd_suspended_title, + getString(message, until), + R.string.dapp_kurd_back, + viewModel::kurdBack + ) + } KurdPageUi.NoticeKind.NO_SITE -> Look( R.drawable.ic_info, R.color.icon_secondary, @@ -471,9 +489,25 @@ class DAppBrowserFragment : BaseFragment R.string.dapp_kurd_suspended_by_court + NameSuspension.By.EMERGENCY -> R.string.dapp_kurd_suspended_by_emergency + } + ) + details.kurdNoticeSuspensionUntil.text = suspension.until.formatDateTime() + details.kurdNoticeSuspensionReason.text = suspension.reason.let { "${it.take(6)}…${it.takeLast(4)}" } + } + /** Storage, cookies and permissions the page kept under its name; then it loads afresh. */ private fun clearKurdSiteData(name: KurdName) { val origin = "https://${name.name}" diff --git a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUi.kt b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUi.kt index e655f47a..27398250 100644 --- a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUi.kt +++ b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUi.kt @@ -2,6 +2,7 @@ package io.novafoundation.nova.feature_dapp_impl.presentation.browser.main.kurd import io.novafoundation.nova.runtime.names.KurdName import io.novafoundation.nova.runtime.names.NameRecord +import io.novafoundation.nova.runtime.names.NameSuspension import io.novafoundation.nova.runtime.names.content.KurdSiteServer.PageState import java.net.URI @@ -13,7 +14,8 @@ sealed interface KurdPageUi { /** [onChainVersion]: a feed showing the release the chain names, as no newer one could be confirmed. */ class Open(override val name: KurdName, val badge: Badge, val details: Details, val onChainVersion: Boolean = false) : KurdPageUi - class Notice(override val name: KurdName, val kind: NoticeKind) : KurdPageUi + /** [suspension]: who stopped the name and until when, for [NoticeKind.SUSPENDED]. */ + class Notice(override val name: KurdName, val kind: NoticeKind, val suspension: NameSuspension? = null) : KurdPageUi enum class Badge { /** Granted by Parliament, or under such a name: the state's own. */ @@ -26,7 +28,7 @@ sealed interface KurdPageUi { UNVERIFIED, } - enum class NoticeKind { REFUSED, NEEDS_CONSENT, NOT_REGISTERED, NO_SITE, UNAVAILABLE } + enum class NoticeKind { REFUSED, NEEDS_CONSENT, NOT_REGISTERED, SUSPENDED, NO_SITE, UNAVAILABLE } class Details( val badge: Badge, @@ -72,6 +74,7 @@ sealed interface KurdPageUi { is PageState.NeedsConsent -> Notice(name, NoticeKind.NEEDS_CONSENT) PageState.Refused -> Notice(name, NoticeKind.REFUSED) PageState.NotRegistered -> Notice(name, NoticeKind.NOT_REGISTERED) + is PageState.Suspended -> Notice(name, NoticeKind.SUSPENDED, state.suspension) PageState.NoSite -> Notice(name, NoticeKind.NO_SITE) PageState.Unavailable -> Notice(name, NoticeKind.UNAVAILABLE) } diff --git a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/search/DAppSearchViewModel.kt b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/search/DAppSearchViewModel.kt index 03767eee..6195b234 100644 --- a/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/search/DAppSearchViewModel.kt +++ b/feature-dapp-impl/src/main/java/io/novafoundation/nova/feature_dapp_impl/presentation/search/DAppSearchViewModel.kt @@ -23,7 +23,6 @@ import io.novafoundation.nova.feature_dapp_impl.presentation.DAppRouter import io.novafoundation.nova.feature_dapp_impl.presentation.common.dappCategoryToUi import io.novafoundation.nova.feature_dapp_impl.presentation.search.model.DappSearchModel import io.novafoundation.nova.runtime.names.KurdLookalikes -import io.novafoundation.nova.runtime.names.KurdName import io.novafoundation.nova.runtime.names.KurdNameResolver import io.novafoundation.nova.runtime.names.KurdResolution import kotlinx.coroutines.ExperimentalCoroutinesApi @@ -128,7 +127,7 @@ class DAppSearchViewModel( ) is DappSearchResult.KurdName -> DappSearchModel( - title = searchResult.name.name, + title = searchResult.name.name + searchResult.path.takeIf { it != "/" }.orEmpty(), description = resourceManager.getString(R.string.dapp_search_kurd_name_subtitle), iconRes = R.drawable.shield_checkmark_outline, searchResult = searchResult, @@ -143,7 +142,7 @@ class DAppSearchViewModel( is DappSearchResult.Dapp -> searchResult.dapp.url is DappSearchResult.Search -> searchResult.searchUrl is DappSearchResult.Url -> searchResult.url - is DappSearchResult.KurdName -> urlAfterLookalikeCheck(searchResult.name) + is DappSearchResult.KurdName -> urlAfterLookalikeCheck(searchResult) } if (!searchResult.isTrustedByNova) { @@ -166,17 +165,18 @@ class DAppSearchViewModel( * chooses that one. Looked up only when the typed name has such a candidate, and for a few * seconds at most: the opened page still shows by its badge whether it is official. */ - private suspend fun urlAfterLookalikeCheck(typed: KurdName): String { + private suspend fun urlAfterLookalikeCheck(typed: DappSearchResult.KurdName): String { val official = withTimeoutOrNull(LOOKALIKE_CHECK_MILLIS) { - KurdLookalikes.candidates(typed).firstOrNull { candidate -> + KurdLookalikes.candidates(typed.name).firstOrNull { candidate -> val resolution = kurdNameResolver.resolve(candidate) resolution is KurdResolution.Resolved && resolution.verified && resolution.official } - } ?: return DappSearchResult.KurdName(typed).url + } ?: return typed.url - return when (kurdLookalikeWarning.awaitAction(KurdLookalikeWarning(typed, official))) { + return when (kurdLookalikeWarning.awaitAction(KurdLookalikeWarning(typed.name, official))) { + // The official site's home page: the typed path belongs to a different site KurdLookalikeChoice.GO_OFFICIAL -> DappSearchResult.KurdName(official).url - KurdLookalikeChoice.OPEN_TYPED -> DappSearchResult.KurdName(typed).url + KurdLookalikeChoice.OPEN_TYPED -> typed.url } } diff --git a/feature-dapp-impl/src/main/res/layout/view_kurd_notice.xml b/feature-dapp-impl/src/main/res/layout/view_kurd_notice.xml index 0c5148ba..3bce5cd7 100644 --- a/feature-dapp-impl/src/main/res/layout/view_kurd_notice.xml +++ b/feature-dapp-impl/src/main/res/layout/view_kurd_notice.xml @@ -50,6 +50,86 @@ android:lineSpacingMultiplier="1.2" tools:text="@string/dapp_kurd_refused_message" /> + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/feature-dapp-impl/src/test/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUiTest.kt b/feature-dapp-impl/src/test/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUiTest.kt index 299637d8..ea669044 100644 --- a/feature-dapp-impl/src/test/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUiTest.kt +++ b/feature-dapp-impl/src/test/java/io/novafoundation/nova/feature_dapp_impl/presentation/browser/main/kurd/KurdPageUiTest.kt @@ -4,6 +4,7 @@ import io.novafoundation.nova.runtime.names.KurdName import io.novafoundation.nova.runtime.names.KurdResolution import io.novafoundation.nova.runtime.names.NameRecord import io.novafoundation.nova.runtime.names.NameStatus +import io.novafoundation.nova.runtime.names.NameSuspension import io.novafoundation.nova.runtime.names.content.Cid import io.novafoundation.nova.runtime.names.content.KurdSiteServer.PageState import org.junit.Assert.assertEquals @@ -51,6 +52,15 @@ class KurdPageUiTest { assertNull(KurdPageUi.from(name, null)) } + @Test + fun `a suspended name is a notice that carries who stopped it and until when`() { + val suspension = NameSuspension(until = 1_800_000_000_000, reg = 1, reason = "0x00", by = NameSuspension.By.EMERGENCY) + val notice = KurdPageUi.from(name, PageState.Suspended(suspension)) as KurdPageUi.Notice + + assertEquals(KurdPageUi.NoticeKind.SUSPENDED, notice.kind) + assertEquals(suspension, notice.suspension) + } + @Test fun `a feed showing the chain's version says so`() { val resolution = KurdResolution.Resolved(name, leased(), NameStatus.ACTIVE, verified = true) diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdName.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdName.kt index 9fac537b..05b955b0 100644 --- a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdName.kt +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdName.kt @@ -78,6 +78,28 @@ class KurdName private constructor( return KurdName(labels) } + /** + * A `.kurd` page address -- the name and the path, query and fragment after it, as the address + * bar shows and the reader edits it -- or null when the name is invalid ([parse]) or what follows + * it is not a plain URL path. The path is `/` when none is given. + */ + fun parseAddress(input: String): Pair? { + var text = input.trim() + if (text.startsWith("https://", ignoreCase = true)) text = text.substring("https://".length) + val end = text.indexOfFirst { it in "/?#" }.takeIf { it >= 0 } ?: text.length + val name = parse(text.substring(0, end)) ?: return null + + val rest = text.substring(end) + if (rest.isEmpty()) return name to "/" + val path = if (rest.startsWith("/")) rest else "/$rest" + // Printable ASCII only: the page is fetched by path, so nothing may hide in it + if (path.any { it.code <= 0x20 || it.code >= 0x7f }) return null + val uri = runCatching { java.net.URI("https://${name.name}$path") }.getOrNull() ?: return null + if (uri.host != name.name || uri.port != -1 || uri.userInfo != null) return null + + return name to path + } + /** `a-z`, `0-9` and `-`, 1 to 63 bytes, no hyphen at either end and no `--` anywhere. */ fun isValidLabel(label: String): Boolean { if (label.isEmpty() || label.length > MAX_LABEL) return false diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdNameResolver.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdNameResolver.kt index 3e2ab13b..5a331e7f 100644 --- a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdNameResolver.kt +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdNameResolver.kt @@ -131,12 +131,14 @@ class RealKurdNameResolver( companion object { /** + * D23: a suspended name opens nothing, read either way -- a refusal needs no proof. * D18: a proven answer stands; an unproven one opens only for a name nobody could take for an * institution's, and with a warning. */ internal fun judge(name: KurdName, lookup: NameLookup, verified: Boolean): KurdResolution = when (lookup) { NameLookup.NotFound, NameLookup.Lapsed -> KurdResolution.NotFound(name, verified) is NameLookup.Found -> when { + lookup.suspension != null -> KurdResolution.Suspended(name, lookup.suspension, verified) verified -> KurdResolution.Resolved(name, lookup.record, lookup.status, verified = true, block = lookup.block) mustBeVerified(name, lookup) -> KurdResolution.Refused(name) else -> KurdResolution.Resolved(name, lookup.record, lookup.status, verified = false, block = lookup.block) diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdResolution.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdResolution.kt index b5fd426e..9255c93b 100644 --- a/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdResolution.kt +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/KurdResolution.kt @@ -22,6 +22,12 @@ sealed interface KurdResolution { val official: Boolean get() = record.isOfficial } + /** + * Stopped by the court or the emergency council (decision D23): the name and everything under + * it open nothing until the suspension ends or is lifted, however it was read. + */ + class Suspended(override val name: KurdName, val suspension: NameSuspension, val verified: Boolean) : KurdResolution + /** Not registered, expired, or orphaned by its parent's re-registration. */ class NotFound(override val name: KurdName, val verified: Boolean) : KurdResolution diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameLookup.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameLookup.kt index 7d3c9b44..21ed990e 100644 --- a/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameLookup.kt +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameLookup.kt @@ -28,7 +28,7 @@ sealed interface NameLookup { /** Two sources agree when they return the same records byte for byte and judge them the same. */ fun agreesWith(other: NameLookup): Boolean = when (this) { - is Found -> other is Found && rawChain == other.rawChain && status == other.status && locked == other.locked + is Found -> other is Found && rawChain == other.rawChain && status == other.status && locked == other.locked && suspension == other.suspension else -> this === other } @@ -46,12 +46,15 @@ sealed interface NameLookup { val locked: Boolean, /** The finalized block it was read at, when the source said; not part of agreement. */ val block: Long? = null, + /** The suspension that stops the name now: its own, or a name's it sits under. */ + val suspension: NameSuspension? = null, ) : NameLookup companion object { private val NAMES_PREFIX = "Navnisan".toByteArray().xxHash128() + "Names".toByteArray().xxHash128() private val LOCKED_PREFIX = "Navnisan".toByteArray().xxHash128() + "Locked".toByteArray().xxHash128() + private val SUSPENSIONS_PREFIX = "Navnisan".toByteArray().xxHash128() + "Suspensions".toByteArray().xxHash128() private val TIMESTAMP_NOW = "Timestamp".toByteArray().xxHash128() + "Now".toByteArray().xxHash128() /** `NavnisanGracePeriod`: 30 days after a lease ends the name still resolves (decision D11). */ @@ -61,6 +64,8 @@ sealed interface NameLookup { fun lockedKey(node: ByteArray) = LOCKED_PREFIX + node + fun suspensionsKey(node: ByteArray) = SUSPENSIONS_PREFIX + node + val timestampNowKey: ByteArray get() = TIMESTAMP_NOW.copyOf() /** @@ -87,10 +92,30 @@ sealed interface NameLookup { val status = effectiveStatus(records.map { it.first }, now) ?: return Lapsed val locked = nodes.any { reader.storage(lockedKey(it), at) != null } + val suspension = suspension(reader, at, nodes, records.map { it.first }, now) val block = runCatching { reader.blockNumber(at) }.getOrNull() - return Found(records.first().first, status, records.map { it.second }, locked, block) + return Found(records.first().first, status, records.map { it.second }, locked, block, suspension) + } + + /** + * `Pezpallet::is_suspended`: the name's own suspension, then each ancestor's while the name + * below is a subname. A chain without `Suspensions` stores nothing there, and nothing is stopped. + */ + private suspend fun suspension( + reader: NameStorageReader, + at: String, + nodes: List, + chain: List, + now: Long, + ): NameSuspension? { + for (level in chain.indices) { + val suspension = reader.storage(suspensionsKey(nodes[level]), at)?.let(NameSuspension::decode) + if (suspension != null && suspension.holdsFor(chain[level], now)) return suspension + if (chain[level].kind != NameRecord.Kind.SUB) return null + } + return null } /** diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameSuspension.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameSuspension.kt new file mode 100644 index 00000000..2e5cd716 --- /dev/null +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/NameSuspension.kt @@ -0,0 +1,46 @@ +package io.novafoundation.nova.runtime.names + +import io.novasama.substrate_sdk_android.extensions.toHexString + +/** + * `pezpallet_navnisan::Suspension`, decoded from the raw value of `Navnisan::Suspensions[node]`: + * the court, or the emergency council, has stopped a name until [until] (decision D23). While it + * holds the name and every name under it resolve to nothing. + */ +data class NameSuspension( + /** Milliseconds, chain time; the suspension ends by itself then. */ + val until: Long, + /** The registration suspended; a name registered anew is not. */ + val reg: Long, + /** Hash of the written reasons, hex with `0x`. */ + val reason: String, + val by: By, +) { + + enum class By { COURT, EMERGENCY } + + /** `Pezpallet::suspension_of`: for this registration, and not yet run out. */ + fun holdsFor(record: NameRecord, now: Long): Boolean = reg == record.reg && now < until + + companion object { + + fun decode(bytes: ByteArray): NameSuspension { + val reader = ScaleReader(bytes) + val suspension = with(reader) { + NameSuspension( + until = u64().toLong(), + reg = u64().toLong(), + reason = bytes(32).toHexString(withPrefix = true), + by = when (val index = u8()) { + 0 -> By.COURT + 1 -> By.EMERGENCY + else -> error("Unknown suspension variant $index") + }, + ) + } + require(reader.isExhausted) { "Trailing bytes after a suspension" } + + return suspension + } + } +} diff --git a/runtime/src/main/java/io/novafoundation/nova/runtime/names/content/KurdSiteServer.kt b/runtime/src/main/java/io/novafoundation/nova/runtime/names/content/KurdSiteServer.kt index b9cd1013..065e40b3 100644 --- a/runtime/src/main/java/io/novafoundation/nova/runtime/names/content/KurdSiteServer.kt +++ b/runtime/src/main/java/io/novafoundation/nova/runtime/names/content/KurdSiteServer.kt @@ -4,6 +4,7 @@ import io.novafoundation.nova.runtime.names.KurdName import io.novafoundation.nova.runtime.names.KurdNameResolver import io.novafoundation.nova.runtime.names.KurdResolution import io.novafoundation.nova.runtime.names.NameRecord +import io.novafoundation.nova.runtime.names.NameSuspension import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.update @@ -50,6 +51,9 @@ class KurdSiteServer( object NotRegistered : PageState + /** Stopped by the court or the emergency council; nothing of it is served. */ + class Suspended(val suspension: NameSuspension) : PageState + /** Registered, but no site: no content, or content of a kind this wallet does not serve. */ object NoSite : PageState @@ -81,15 +85,16 @@ class KurdSiteServer( val name = KurdName.parse(host) ?: return status(404, "Not Found") val segments = decodePath(encodedPath) ?: return status(400, "Bad Request") - val (state, response) = handle(name, segments) + val (state, response) = handle(name, segments, mainFrame) if (mainFrame) _pageStates.update { it + (name to state) } return response } - private suspend fun handle(name: KurdName, segments: List): Pair { + private suspend fun handle(name: KurdName, segments: List, mainFrame: Boolean): Pair { val resolution = when (val resolved = resolve(name)) { is KurdResolution.Resolved -> resolved is KurdResolution.NotFound -> return PageState.NotRegistered to status(404, "Not Found") + is KurdResolution.Suspended -> return PageState.Suspended(resolved.suspension) to status(451, "Unavailable For Legal Reasons") is KurdResolution.Refused -> return PageState.Refused to status(403, "Forbidden") is KurdResolution.Unavailable -> return PageState.Unavailable to status(502, "Bad Gateway") } @@ -112,11 +117,23 @@ class KurdSiteServer( val open = PageState.Open(resolution, root, onChainVersion) return when (val result = fetcher.fetch(root, segments)) { is KurdContentFetcher.Result.File -> open to Response(200, "OK", mimeTypeOf(result.path.lastOrNull()), result.bytes) - KurdContentFetcher.Result.NotFound -> open to status(404, "Not Found") + KurdContentFetcher.Result.NotFound -> open to if (mainFrame) notFoundPage(root) else status(404, "Not Found") KurdContentFetcher.Result.Unavailable -> PageState.Unavailable to status(502, "Bad Gateway") } } + /** + * A page the site does not have: its own `/404.html` when it ships one, as a web server would + * answer, and otherwise a line of text. Never an empty body, which WebView replaces with its + * own error screen as if the site could not be reached. + */ + private suspend fun notFoundPage(root: Cid): Response { + val page = fetcher.fetch(root, listOf(NOT_FOUND_PAGE)) as? KurdContentFetcher.Result.File + ?: return Response(404, "Not Found", "text/plain", "404 Not Found".toByteArray()) + + return Response(404, "Not Found", mimeTypeOf(NOT_FOUND_PAGE), page.bytes) + } + private suspend fun resolve(name: KurdName): KurdResolution { val now = clock() resolutions[name]?.let { (at, resolution) -> if (now - at < resolutionTtlMillis) return resolution } @@ -127,6 +144,8 @@ class KurdSiteServer( companion object { + private const val NOT_FOUND_PAGE = "404.html" + const val CONTENT_SECURITY_POLICY = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; " + "img-src 'self' data: blob:; media-src 'self' blob:; font-src 'self' data:; connect-src 'self'; " + "worker-src 'none'; object-src 'none'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'" diff --git a/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdNameTest.kt b/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdNameTest.kt index a3af36fd..67e2ceba 100644 --- a/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdNameTest.kt +++ b/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdNameTest.kt @@ -32,6 +32,28 @@ class KurdNameTest { assertEquals("gov", KurdName.parse("serok.gov.kurd")!!.top) } + @Test + fun `a page address keeps its path, query and fragment`() { + assertEquals("dks-news.kurd" to "/kategori/ekonomi", address("https://DKS-News.kurd/kategori/ekonomi")) + assertEquals("dks-news.kurd" to "/a/x?lang=kmr#top", address("dks-news.kurd/a/x?lang=kmr#top")) + assertEquals("dks-news.kurd" to "/?q=1", address("dks-news.kurd?q=1")) + assertEquals("dks.kurd" to "/", address("dks.kurd")) + assertEquals("dks.kurd" to "/", address("https://dks.kurd/")) + } + + @Test + fun `a page address with an invalid name, port, user or unsafe path is refused`() { + listOf( + "dks_news.kurd/a", // the name itself + "dks.kurd:8080/a", + "user@dks.kurd/a", + "http://dks.kurd/a", // only https, as for a bare name + "dks.kurd/a b", + "dks.kurd/\u00e7", + "dks.kurd/a%zz", + ).forEach { assertNull(it, KurdName.parseAddress(it)) } + } + @Test fun `names the pallet refuses are never parsed`() { listOf( @@ -84,4 +106,6 @@ class KurdNameTest { } private fun node(name: String) = KurdName.parse(name)!!.node.toHexString() + + private fun address(input: String) = KurdName.parseAddress(input)?.let { (name, path) -> name.name to path } } diff --git a/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdResolutionJudgeTest.kt b/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdResolutionJudgeTest.kt index cd5650b7..c6b80491 100644 --- a/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdResolutionJudgeTest.kt +++ b/runtime/src/test/java/io/novafoundation/nova/runtime/names/KurdResolutionJudgeTest.kt @@ -3,6 +3,7 @@ package io.novafoundation.nova.runtime.names import io.novafoundation.nova.runtime.names.RealKurdNameResolver.Companion.judge import io.novafoundation.nova.runtime.names.RealKurdNameResolver.Companion.refuseOrGiveUp import org.junit.Assert.assertFalse +import org.junit.Assert.assertSame import org.junit.Assert.assertTrue import org.junit.Test @@ -35,6 +36,18 @@ class KurdResolutionJudgeTest { assertFalse(resolution.official) } + @Test + fun `a suspended name is suspended however it was read, even one that must be verified`() { + val suspension = NameSuspension(until = 1, reg = 9, reason = "0x00", by = NameSuspension.By.COURT) + val stopped = { raw: NameRecord -> NameLookup.Found(raw, NameStatus.ACTIVE, listOf("raw"), locked = false, suspension = suspension) } + + val proven = judge(ahmet, stopped(leased()), verified = true) as KurdResolution.Suspended + assertTrue(proven.verified) + assertSame(suspension, proven.suspension) + assertTrue(judge(ahmet, stopped(leased()), verified = false) is KurdResolution.Suspended) + assertTrue(judge(dks, stopped(NameRecord.decode(NameFixtures.DKS)), verified = false) is KurdResolution.Suspended) + } + @Test fun `with no answer a zone name is refused and any other is unavailable`() { assertTrue(refuseOrGiveUp(KurdName.parse("serok.gov.kurd")!!) is KurdResolution.Refused) diff --git a/runtime/src/test/java/io/novafoundation/nova/runtime/names/NameLookupTest.kt b/runtime/src/test/java/io/novafoundation/nova/runtime/names/NameLookupTest.kt index dcda2668..205de28e 100644 --- a/runtime/src/test/java/io/novafoundation/nova/runtime/names/NameLookupTest.kt +++ b/runtime/src/test/java/io/novafoundation/nova/runtime/names/NameLookupTest.kt @@ -107,6 +107,76 @@ class NameLookupTest { assertFalse(first.agreesWith(NameLookup.NotFound)) } + @Test + fun `a suspension of the name or of the name above it stops it`() = runBlocking { + val govReg = NameRecord.decode(NameFixtures.GOV).reg + val serokReg = NameRecord.decode(NameFixtures.SEROK_GOV).reg + val live = { FakeReader().put(gov, NameFixtures.GOV).put(serok, NameFixtures.SEROK_GOV) } + + assertEquals(null, (NameLookup.read(live(), serok) as NameLookup.Found).suspension) + + val own = NameLookup.read(live().suspend(serok, serokReg, NameSuspension.By.EMERGENCY), serok) as NameLookup.Found + assertEquals(NameSuspension.By.EMERGENCY, own.suspension?.by) + + val above = NameLookup.read(live().suspend(gov, govReg, NameSuspension.By.COURT), serok) as NameLookup.Found + assertEquals(NameSuspension.By.COURT, above.suspension?.by) + assertEquals(NameFixtures.NOW + 1, above.suspension?.until) + } + + @Test + fun `a suspension that ran out or names another registration stops nothing`() = runBlocking { + val serokReg = NameRecord.decode(NameFixtures.SEROK_GOV).reg + val live = { FakeReader().put(gov, NameFixtures.GOV).put(serok, NameFixtures.SEROK_GOV) } + + val ranOut = live().suspend(serok, serokReg, NameSuspension.By.COURT, until = NameFixtures.NOW) + assertEquals(null, (NameLookup.read(ranOut, serok) as NameLookup.Found).suspension) + + val earlier = live().suspend(serok, serokReg - 1, NameSuspension.By.COURT) + assertEquals(null, (NameLookup.read(earlier, serok) as NameLookup.Found).suspension) + } + + @Test + fun `a suspension above a name that is not a subname does not reach it`() = runBlocking { + // serok.gov.kurd as if Parliament had granted it outright rather than set it under gov.kurd + val granted = NameFixtures.SEROK_GOV.copyOf().also { it[SEROK_KIND_OFFSET] = 1 } + check(NameRecord.decode(granted).kind == NameRecord.Kind.GRANTED) + val reader = FakeReader().put(gov, NameFixtures.GOV).put(serok, granted) + .suspend(gov, NameRecord.decode(NameFixtures.GOV).reg, NameSuspension.By.COURT) + + assertEquals(null, (NameLookup.read(reader, serok) as NameLookup.Found).suspension) + } + + @Test + fun `sources that disagree on a suspension do not agree`() = runBlocking { + val serokReg = NameRecord.decode(NameFixtures.SEROK_GOV).reg + val live = { FakeReader().put(gov, NameFixtures.GOV).put(serok, NameFixtures.SEROK_GOV) } + + val plain = NameLookup.read(live(), serok) + val stopped = NameLookup.read(live().suspend(serok, serokReg, NameSuspension.By.COURT), serok) + assertFalse(plain.agreesWith(stopped)) + assertTrue(stopped.agreesWith(NameLookup.read(live().suspend(serok, serokReg, NameSuspension.By.COURT), serok))) + } + + @Test + fun `suspensions are read from the pallet's own storage item`() { + // twox128("Navnisan") ++ twox128("Suspensions"), computed apart from this code + val prefix = "8dada8db66ab8573e0db54b9f7d276265dd5f3679e83b14ce6d7b388fae08646" + assertEquals(prefix + "00".repeat(32), NameLookup.suspensionsKey(ByteArray(32)).toHexString()) + } + + @Test + fun `a suspension decodes field by field and refuses trailing bytes`() { + val raw = suspensionBytes(until = 0x0102, reg = 7, by = NameSuspension.By.EMERGENCY) + val suspension = NameSuspension.decode(raw) + + assertEquals(0x0102L, suspension.until) + assertEquals(7L, suspension.reg) + assertEquals("0x" + "ab".repeat(32), suspension.reason) + assertEquals(NameSuspension.By.EMERGENCY, suspension.by) + assertTrue(runCatching { NameSuspension.decode(raw + 0) }.isFailure) + assertTrue(runCatching { NameSuspension.decode(raw.copyOf(raw.size - 1) + 2) }.isFailure) + } + private fun record(kind: NameRecord.Kind, expiry: Long?, reg: Long = 1, parentReg: Long = 1) = NameRecord( label = "x", parent = ByteArray(32), parentReg = parentReg, reg = reg, owner = NameRecord.Owner.Governance, kind = kind, lockedTransfer = false, expiry = expiry, account = null, content = null, @@ -125,6 +195,10 @@ class NameLookupTest { fun lock(name: KurdName) = apply { values[NameLookup.lockedKey(name.node).toHexString()] = byteArrayOf(0) } + fun suspend(name: KurdName, reg: Long, by: NameSuspension.By, until: Long = NameFixtures.NOW + 1) = apply { + values[NameLookup.suspensionsKey(name.node).toHexString()] = suspensionBytes(until, reg, by) + } + override suspend fun finalizedHead() = HEAD override suspend fun blockNumber(at: String): Long = 1_284_551 @@ -138,4 +212,16 @@ class NameLookupTest { const val HEAD = "0xfinalized" } } + + companion object { + + /** Label (1 + 5), parent, parent_reg, reg, owner `Office(3)`: the kind byte follows. */ + private const val SEROK_KIND_OFFSET = 6 + 32 + 8 + 8 + 2 + + /** `Suspension { until, reg, reason, by }` as the pallet encodes it. */ + fun suspensionBytes(until: Long, reg: Long, by: NameSuspension.By): ByteArray = + le64(until) + le64(reg) + ByteArray(32) { 0xab.toByte() } + byteArrayOf(by.ordinal.toByte()) + + private fun le64(value: Long) = ByteArray(8) { (value ushr (8 * it)).toByte() } + } } diff --git a/runtime/src/test/java/io/novafoundation/nova/runtime/names/content/KurdSiteServerTest.kt b/runtime/src/test/java/io/novafoundation/nova/runtime/names/content/KurdSiteServerTest.kt index d5863d3f..5d158434 100644 --- a/runtime/src/test/java/io/novafoundation/nova/runtime/names/content/KurdSiteServerTest.kt +++ b/runtime/src/test/java/io/novafoundation/nova/runtime/names/content/KurdSiteServerTest.kt @@ -5,6 +5,7 @@ import io.novafoundation.nova.runtime.names.KurdNameResolver import io.novafoundation.nova.runtime.names.KurdResolution import io.novafoundation.nova.runtime.names.NameRecord import io.novafoundation.nova.runtime.names.NameStatus +import io.novafoundation.nova.runtime.names.NameSuspension import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertNull @@ -37,6 +38,26 @@ class KurdSiteServerTest { assertEquals(404, server(resolved(content = null)).serve(name.name, "/").status) } + @Test + fun `a page the site lacks is its own 404 page, or a line of text, never an empty error`() = runBlocking { + val withPage = KurdSiteServer( + resolverOf(resolved(ipfs(cid("bafybeiezwrv6dr544fbj4xtthdg63jblfzqj5j6cqfkslbf7hkbevgpkui")))), + fetcher(CarSource { _, _, _ -> resource("site-with-404.car") }), + ) + val ownPage = withPage.serve("dks.kurd", "/missing", mainFrame = true) + assertEquals(404, ownPage.status) + assertEquals("text/html", ownPage.mimeType) + assertTrue(String(ownPage.body).contains("404 page")) + + val withoutPage = server(resolved(ipfs(siteRoot))) + val text = withoutPage.serve("dks.kurd", "/missing", mainFrame = true) + assertEquals(404, text.status) + assertTrue(text.body.isNotEmpty()) + + // A missing image or script is answered as before: the page decides what to show + assertEquals(0, withPage.serve("dks.kurd", "/missing.png").body.size) + } + @Test fun `content the server cannot verify is not served`() = runBlocking { val ipns = NameRecord.Content.Ipfs(byteArrayOf(0xe5.toByte(), 0x01) + siteRoot.bytes) @@ -115,6 +136,19 @@ class KurdSiteServerTest { assertSame(KurdSiteServer.PageState.NotRegistered, stateFor { KurdResolution.NotFound(it, verified = true) }) assertSame(KurdSiteServer.PageState.Unavailable, stateFor { KurdResolution.Unavailable(it) }) assertSame(KurdSiteServer.PageState.NoSite, stateFor(resolved(content = null))) + + val suspension = NameSuspension(until = 1, reg = 1, reason = "0x00", by = NameSuspension.By.EMERGENCY) + val suspended = stateFor { KurdResolution.Suspended(it, suspension, verified = true) } + assertSame(suspension, (suspended as KurdSiteServer.PageState.Suspended).suspension) + } + + @Test + fun `a suspended name serves nothing, not even its content when verified`() = runBlocking { + val suspension = NameSuspension(until = 1, reg = 1, reason = "0x00", by = NameSuspension.By.COURT) + val response = server { KurdResolution.Suspended(it, suspension, verified = true) }.serve("dks.kurd", "/") + + assertEquals(451, response.status) + assertTrue(response.body.isEmpty()) } @Test diff --git a/runtime/src/test/resources/kurd-content/README.md b/runtime/src/test/resources/kurd-content/README.md index 2d83d971..4ae9df4b 100644 --- a/runtime/src/test/resources/kurd-content/README.md +++ b/runtime/src/test/resources/kurd-content/README.md @@ -2,3 +2,7 @@ CAR fixtures from [ipfs/gateway-conformance](https://github.com/ipfs/gateway-con at commit `eaca278518dc977db10bfec4acd79c92c4ee11ac` (`fixtures/trustless_gateway_car/` and `fixtures/path_gateway_unixfs/`), produced by Kubo. Dual licensed MIT / Apache-2.0 by their authors. Unmodified; used to check the wallet's CAR and UnixFS verifier against the reference implementation. + +`site-with-404.car` is the wallet's own: a directory holding `index.html` and `404.html`, added with +Kubo 0.43.1 (`ipfs add -r --cid-version 1 --raw-leaves`, root +`bafybeiezwrv6dr544fbj4xtthdg63jblfzqj5j6cqfkslbf7hkbevgpkui`) and exported with `ipfs dag export`. diff --git a/runtime/src/test/resources/kurd-content/site-with-404.car b/runtime/src/test/resources/kurd-content/site-with-404.car new file mode 100644 index 0000000000000000000000000000000000000000..11e5c4b12b1944141ebed338b212a172e24e73ea GIT binary patch literal 355 zcmcColvRxd%1DUB}0uebY zR&DNz+APFjVql_|QIeY@p)OsPmW1cmopd$prpLdWfeUI?4a<#$Sp zOvUYmxH9unQY#?3l)0EV7`=(H%0@9IKe?o`AXNcmot;fdW=T$}9ngA(g2ePx8+{0$ S%N=AEAtzurD