🥮 mooncakes.io
    Sign in

    proton_rsa

    RSASSA-PKCS1-v1_5 signature verification over SHA-256.

    rsa
    pkcs1
    signature
    verification
    Download zip
    Version
    0.6.0
    License
    Apache-2.0
    Repository
    Last updated
    10 hours ago
    Downloads
    26K

    #moonbit-community/proton_rsa

    RSASSA-PKCS1-v1_5 signature verification over SHA-256, in pure MoonBit.

    This package exists to verify Proton update manifests and artifacts.

    #Scope

    Verification only, using SHA-256. Key generation and signing are not provided.

    #Use

    let key = @rsa.PublicKey::parse(public_key_pem)
    let digest = compute_sha256_of_the_artifact()
    if @rsa.verify_pkcs1_sha256(key, digest, signature) {
      // The signature is valid.
    }

    verify_pkcs1_sha256 takes a digest rather than the signed content, so a large artifact can be streamed through a hash instead of being held in memory.

    public_key_pem is the PEM text, not a file path. Both SubjectPublicKeyInfo (-----BEGIN PUBLIC KEY-----) and PKCS#1 (-----BEGIN RSA PUBLIC KEY-----) are accepted. Private keys, certificates, and the former custom key encoding are rejected. PEM and DER decoding use oilleelssq-wq/MoonBit-PKI.

    Export a public key with OpenSSL:

    openssl pkey -in updater-private.pem -pubout -out updater-public.pem

    #Validation

    Verification returns false for invalid signatures. Signature length must equal the modulus length. Public keys require a modulus of at least 2048 bits and an odd exponent of at least 3, smaller than the modulus.

    #Trust

    It verifies a signature against a key it is given. It has nothing to say about where that key came from, whether the key is still trusted, or whether the signed version is newer than the running one. Key custody, rotation, and rollback protection belong to the caller.

    KeyError

    source
    pub(all) suberror KeyError {
      Malformed(detail~ : String)
      ModulusTooSmall(bits~ : Int, minimum~ : Int)
      InvalidExponent(detail~ : String)
    } derive(Eq, 
    Debug    )

    A trusted public key could not be decoded.

    Every variant describes a defect in configuration, not in a signature. Signature verification itself never raises: it answers with a boolean, so that no caller can mistake an error path for a successful check.

    KeyError::equal

    source
    fn KeyError::equal(KeyError, KeyError) -> Bool

    KeyError::message

    source
    fn KeyError::message(self : KeyError) -> String

    KeyError::not_equal

    source
    fn KeyError::not_equal(x : KeyError, y : KeyError) -> Bool

    KeyError::output

    source
    fn KeyError::output(self : KeyError, logger : &Logger) -> Unit

    KeyError::to_repr

    source

    KeyError::to_string

    source
    fn KeyError::to_string(self : KeyError) -> String

    PublicKey

    source
    pub struct PublicKey {
      modulus : 
    BigInt
      exponent : 
    BigInt
      size : Int
    }

    An RSA public key that verifies RSASSA-PKCS1-v1_5 signatures over SHA-256.

    PublicKey::bits

    source
    fn PublicKey::bits(self : PublicKey) -> Int

    Returns the modulus length in bits.

    PublicKey::parse

    source
    fn PublicKey::parse(text : String) -> PublicKey raise KeyError

    Parses a PEM-encoded RSA public key.

    Accepts SubjectPublicKeyInfo (PUBLIC KEY, produced by openssl pkey -pubout) and PKCS#1 (RSA PUBLIC KEY). Private keys and certificates are not accepted.

    PublicKey::size

    source
    fn PublicKey::size(self : PublicKey) -> Int

    Returns the modulus length in bytes.

    minimum_modulus_bits

    source
    let minimum_modulus_bits : Int

    The smallest modulus this package will accept.

    1024-bit RSA is considered broken for signatures and 2048 is the current floor in every serious guideline. Refusing a short key is a security control in its own right: a key that is too small verifies signatures perfectly well and offers no protection.

    sha256_digest_length

    source
    let sha256_digest_length : Int

    Length of a SHA-256 digest in bytes.

    verify_pkcs1_sha256

    source
    fn verify_pkcs1_sha256(key : PublicKey, digest : Bytes, signature : Bytes) -> Bool

    Verifies an RSASSA-PKCS1-v1_5 signature over a SHA-256 digest.

    digest is the 32-byte SHA-256 of the signed content; the caller hashes, which lets a large artifact be streamed rather than held in memory. signature is the raw big-endian signature, exactly key.size() bytes.

    Returns true only for a signature that verifies. Every other outcome — wrong length, out-of-range signature, malformed padding, wrong digest — is false. Verification deliberately cannot raise: a caller that distinguished "invalid" from "failed to check" would eventually treat one as the other, and this function decides whether foreign code is allowed to run.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io