implement X509; include "sys.m"; sys : Sys; include "asn1.m"; asn1 : ASN1; Elem, Tag, Value, Oid, Universal, Context, BOOLEAN, INTEGER, BIT_STRING, OCTET_STRING, OBJECT_ID, SEQUENCE, UTCTime, IA5String, GeneralString, GeneralizedTime : import asn1; include "keyring.m"; keyring : Keyring; IPint, DESstate : import keyring; include "security.m"; random : Random; include "daytime.m"; daytime : Daytime; include "pkcs.m"; pkcs : PKCS; include "x509.m"; X509_DEBUG : con 0; logfd : ref Sys->FD; TAG_MASK : con 16r1F; CONSTR_MASK : con 16r20; CLASS_MASK : con 16rC0; # object identifiers objIdTab = array [] of { id_at => Oid(array [] of {2,5,4}), id_at_commonName => Oid(array [] of {2,5,4,3}), id_at_countryName => Oid(array [] of {2,5,4,6}), id_at_localityName => Oid(array [] of {2,5,4,7}), id_at_stateOrProvinceName => Oid(array [] of {2,5,4,8}), id_at_organizationName => Oid(array [] of {2,5,4,10}), id_at_organizationalUnitName => Oid(array [] of {2,5,4,11}), id_at_userPassword => Oid(array [] of {2,5,4,35}), id_at_userCertificate => Oid(array [] of {2,5,4,36}), id_at_cAcertificate => Oid(array [] of {2,5,4,37}), id_at_authorityRevocationList => Oid(array [] of {2,5,4,38}), id_at_certificateRevocationList => Oid(array [] of {2,5,4,39}), id_at_crossCertificatePair => Oid(array [] of {2,5,4,40}), # id_at_crossCertificatePair => Oid(array [] of {2,5,4,58}), id_at_supportedAlgorithms => Oid(array [] of {2,5,4,52}), id_at_deltaRevocationList => Oid(array [] of {2,5,4,53}), id_ce => Oid(array [] of {2,5,29}), id_ce_subjectDirectoryAttributes => Oid(array [] of {2,5,29,9}), id_ce_subjectKeyIdentifier => Oid(array [] of {2,5,29,14}), id_ce_keyUsage => Oid(array [] of {2,5,29,15}), id_ce_privateKeyUsage => Oid(array [] of {2,5,29,16}), id_ce_subjectAltName => Oid(array [] of {2,5,29,17}), id_ce_issuerAltName => Oid(array [] of {2,5,29,18}), id_ce_basicConstraints => Oid(array [] of {2,5,29,19}), id_ce_cRLNumber => Oid(array [] of {2,5,29,20}), id_ce_reasonCode => Oid(array [] of {2,5,29,21}), id_ce_instructionCode => Oid(array [] of {2,5,29,23}), id_ce_invalidityDate => Oid(array [] of {2,5,29,24}), id_ce_deltaCRLIndicator => Oid(array [] of {2,5,29,27}), id_ce_issuingDistributionPoint => Oid(array [] of {2,5,29,28}), id_ce_certificateIssuer => Oid(array [] of {2,5,29,29}), id_ce_nameConstraints => Oid(array [] of {2,5,29,30}), id_ce_cRLDistributionPoint => Oid(array [] of {2,5,29,31}), id_ce_certificatePolicies => Oid(array [] of {2,5,29,32}), id_ce_policyMapping => Oid(array [] of {2,5,29,33}), id_ce_authorityKeyIdentifier => Oid(array [] of {2,5,29,35}), id_ce_policyConstraints => Oid(array [] of {2,5,29,36}), # id_mr => Oid(array [] of {2,5,?}), # id_mr_certificateMatch => Oid(array [] of {2,5,?,35}), # id_mr_certificatePairExactMatch => # Oid(array [] of {2,5,?,36}), # id_mr_certificatePairMatch => Oid(array [] of {2,5,?,37}), # id_mr_certificateListExactMatch => # Oid(array [] of {2,5,?,38}), # id_mr_certificateListMatch => Oid(array [] of {2,5,?,39}), # id_mr_algorithmidentifierMatch => # Oid(array [] of {2,5,?,40}) }; # [public] init(): string { sys = load Sys Sys->PATH; if(X509_DEBUG) logfd = sys->fildes(1); keyring = load Keyring Keyring->PATH; if(keyring == nil) return sys->sprint("load %s: %r", Keyring->PATH); random = load Random Random->PATH; if(random == nil) return sys->sprint("load %s: %r", Random->PATH); daytime = load Daytime Daytime->PATH; if(daytime == nil) return sys->sprint("load %s: %r", Daytime->PATH); asn1 = load ASN1 ASN1->PATH; if(asn1 == nil) return sys->sprint("load %s: %r", ASN1->PATH); asn1->init(); pkcs = load PKCS PKCS->PATH; if(pkcs == nil) return sys->sprint("load %s: %r", PKCS->PATH); if((e := pkcs->init()) != nil) return sys->sprint("pkcs: %s", e); return nil; } # [private] log(s: string) { if(X509_DEBUG) sys->fprint(logfd, "x509: %s\n", s); } ## SIGNED { ToBeSigned } ::= SEQUENCE { ## toBeSigned ToBeSigned, ## COMPONENTS OF SIGNATURE { ToBeSigned }} ## ## SIGNATURE {OfSignature} ::= SEQUENCE { ## algorithmIdentifier AlgorithmIdentifier, ## encrypted ENCRYPTED { HASHED { OfSignature }}} ## ## ENCRYPTED { ToBeEnciphered } ::= BIT STRING ( CONSTRAINED BY { ## -- must be the result of applying an encipherment procedure -- ## -- to the BER-encoded octets of a value of -- ToBeEnciphered } ) # [public] Signed.decode(a: array of byte): (string, ref Signed) { parse: for(;;) { # interpret the enclosing structure (ok, tag, i, n) := der_dec1(a, 0, len a); if(!ok || n != len a || !tag.constr || tag.class != Universal || tag.num != SEQUENCE) break parse; s := ref Signed; # SIGNED sequence istart := i; (ok, tag, i, n) = der_dec1(a, i, len a); if(!ok || n == len a) break parse; s.tobe_signed = a[istart:n]; # AlgIdentifier istart = n; (ok, tag, i, n) = der_dec1(a, n, len a); if(!ok || n == len a || !tag.constr || tag.class != Universal || tag.num != SEQUENCE) { if(X509_DEBUG) log("signed: der data: " + sys->sprint("ok=%d, n=%d, constr=%d, class=%d, num=%d", ok, n, tag.constr, tag.class, tag.num)); break parse; } (ok, s.alg) = decode_algid(a[istart:n]); if(!ok) { if(X509_DEBUG) log("signed: alg identifier: syntax error"); break; } # signature (ok, tag, i, n) = der_dec1(a, n, len a); if(!ok || n != len a || tag.constr || tag.class != Universal || tag.num != BIT_STRING) { if(X509_DEBUG) log("signed: signature: " + sys->sprint("ok=%d, n=%d, constr=%d, class=%d, num=%d", ok, n, tag.constr, tag.class, tag.num)); break parse; } s.signature = a[i:n]; # to the end of no error been found return ("", s); } return ("signed: syntax error", nil); } # [public] # der encoding of signed data Signed.encode(s: self ref Signed): (string, array of byte) { (err, e_dat) := asn1->decode(s.tobe_signed); # why? if(err != "") return (err, nil); e_alg := pack_alg(s.alg); e_sig := ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0,s.signature) # DER encode of BIT STRING ); all := ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(e_dat::e_alg::e_sig::nil) ); return asn1->encode(all); } # [public] Signed.sign(s: self ref Signed, sk: ref PrivateKey, hash: int): (string, array of byte) { # we require tobe_signed has 0 bits of padding if(int s.tobe_signed[0] != 0) return ("syntax error", nil); pick key := sk { RSA => (err, signature) := pkcs->rsa_sign(s.tobe_signed, key.sk, hash); s.signature = signature; # TODO: add AlgIdentifier based on public key and hash return (err, signature); DSS => # TODO: hash s.tobe_signed for signing (err, signature) := pkcs->dss_sign(s.tobe_signed, key.sk); s.signature = signature; return (err, signature); DH => return ("cannot sign using DH algorithm", nil); } return ("sign: failed", nil); } # [public] # hash algorithm should be MD2, MD4, MD5 or SHA Signed.verify(s: self ref Signed, pk: ref PublicKey, hash: int): int { ok := 0; pick key := pk { RSA => ok = pkcs->rsa_verify(s.tobe_signed, s.signature, key.pk, hash); DSS => # TODO: hash s.tobe_signed for verifying ok = pkcs->dss_verify(s.tobe_signed, s.signature, key.pk); DH => # simply failure } return ok; } # [public] Signed.tostring(s: self ref Signed): string { str := "Signed"; str += "\nToBeSigned: " + bastr(s.tobe_signed); str += "\nAlgorithm: " + s.alg.tostring(); str += "\nSignature: " + bastr(s.signature); return str + "\n"; } # DER # a) the definite form of length encoding shall be used, encoded in the minimum number of # octets; # b) for string types, the constructed form of encoding shall not be used; # c) if the value of a type is its default value, it shall be absent; # d) the components of a Set type shall be encoded in ascending order of their tag value; # e) the components of a Set-of type shall be encoded in ascending order of their octet value; # f) if the value of a Boolean type is true, the encoding shall have its contents octet # set to "FF"16; # g) each unused bits in the final octet of the encoding of a Bit String value, if there are # any, shall be set to zero; # h) the encoding of a Real type shall be such that bases 8, 10, and 16 shall not be used, # and the binary scaling factor shall be zero. # [private] # decode ASN1 one record at a time and return (err, tag, start of data, # end of data) for indefinite length, the end of data is same as 'n' der_dec1(a: array of byte, i, n: int): (int, Tag, int, int) { length: int; tag: Tag; ok := 1; (ok, i, tag) = der_dectag(a, i, n); if(ok) { (ok, i, length) = der_declen(a, i, n); if(ok) { if(length == -1) { if(!tag.constr) ok = 0; length = n - i; } else { if(i+length > n) ok = 0; } } } if(!ok && X509_DEBUG) log("der_dec1: syntax error"); return (ok, tag, i, i+length); } # [private] # der tag decode der_dectag(a: array of byte, i, n: int): (int, int, Tag) { ok := 1; class, num, constr: int; if(n-i >= 2) { v := int a[i++]; class = v & CLASS_MASK; if(v & CONSTR_MASK) constr = 1; else constr = 0; num = v & TAG_MASK; if(num == TAG_MASK) # long tag number (ok, i, num) = uint7_decode(a, i, n); } else ok = 0; if(!ok && X509_DEBUG) log("der_declen: syntax error"); return (ok, i, Tag(class, num, constr)); } # [private] int_decode(a: array of byte, i, n, count, unsigned: int): (int, int, int) { ok := 1; num := 0; if(n-i >= count) { if((count > 4) || (unsigned && count == 4 && (int a[i] & 16r80))) ok = 1; else { if(!unsigned && count > 0 && count < 4 && (int a[i] & 16r80)) num = -1; # all bits set for(j := 0; j < count; j++) { v := int a[i++]; num = (num << 8) | v; } } } else ok = 0; if(!ok && X509_DEBUG) log("int_decode: syntax error"); return (ok, i, num); } # [private] uint7_decode(a: array of byte, i, n: int) : (int, int, int) { ok := 1; num := 0; more := 1; while(more && i < n) { v := int a[i++]; if(num & 16r7F000000) { ok = 0; break; } num <<= 7; more = v & 16r80; num |= (v & 16r7F); } if(n == i) ok = 0; if(!ok && X509_DEBUG) log("uint7_decode: syntax error"); return (ok, i, num); } # [private] # der length decode - the definite form of length encoding shall be used, encoded # in the minimum number of octets der_declen(a: array of byte, i, n: int): (int, int, int) { ok := 1; num := 0; if(i < n) { v := int a[i++]; if(v & 16r80) return int_decode(a, i, n, v&16r7F, 1); else if(v == 16r80) # indefinite length ok = 0; else num = v; } else ok = 0; if(!ok && X509_DEBUG) log("der_declen: syntax error"); return (ok, i, num); } # [private] # parse der encoded algorithm identifier decode_algid(a: array of byte): (int, ref AlgIdentifier) { (err, el) := asn1->decode(a); if(err != "") { if(X509_DEBUG) log("decode_algid: " + err); return (0, nil); } return parse_alg(el); } ## TBS (Public Key) Certificate is signed by Certificate Authority and contains ## information of public key usage (as a comparison of Certificate Revocation List ## and Attribute Certificate). # [public] # constructs a certificate by parsing a der encoded certificate # returns error if parsing is failed or nil if parsing is ok certsyn(s: string): (string, ref Certificate) { if(0) sys->fprint(sys->fildes(2), "cert: %s\n", s); return ("certificate syntax: "+s, nil); } # Certificate ::= SEQUENCE { # certificateInfo CertificateInfo, # signatureAlgorithm AlgorithmIdentifier, # signature BIT STRING } # # CertificateInfo ::= SEQUENCE { # version [0] INTEGER DEFAULT v1 (0), # serialNumber INTEGER, # signature AlgorithmIdentifier, # issuer Name, # validity Validity, # subject Name, # subjectPublicKeyInfo SubjectPublicKeyInfo } # (version v2 has two more fields, optional unique identifiers for # issuer and subject; since we ignore these anyway, we won't parse them) # # Validity ::= SEQUENCE { # notBefore UTCTime, # notAfter UTCTime } # # SubjectPublicKeyInfo ::= SEQUENCE { # algorithm AlgorithmIdentifier, # subjectPublicKey BIT STRING } # # AlgorithmIdentifier ::= SEQUENCE { # algorithm OBJECT IDENTIFER, # parameters ANY DEFINED BY ALGORITHM OPTIONAL } # # Name ::= SEQUENCE OF RelativeDistinguishedName # # RelativeDistinguishedName ::= SETOF SIZE(1..MAX) OF AttributeTypeAndValue # # AttributeTypeAndValue ::= SEQUENCE { # type OBJECT IDENTIFER, # value DirectoryString } # (selected attributes have these Object Ids: # commonName {2 5 4 3} # countryName {2 5 4 6} # localityName {2 5 4 7} # stateOrProvinceName {2 5 4 8} # organizationName {2 5 4 10} # organizationalUnitName {2 5 4 11} # ) # # DirectoryString ::= CHOICE { # teletexString TeletexString, # printableString PrintableString, # universalString UniversalString } # # See rfc1423, rfc2437 for AlgorithmIdentifier, subjectPublicKeyInfo, signature. Certificate.decode(a: array of byte): (string, ref Certificate) { parse: # break on error for(;;) { (err, all) := asn1->decode(a); if(err != "") return certsyn(err); c := ref Certificate; # certificate must be a ASN1 sequence (ok, el) := all.is_seq(); if(!ok) return certsyn("invalid certificate sequence"); if(len el == 3){ # ssl3.b uses CertificateInfo; others use Certificate (TO DO: fix this botch) certinfo := hd el; sigalgid := hd tl el; sigbits := hd tl tl el; # certificate info is another ASN1 sequence (ok, el) = certinfo.is_seq(); if(!ok || len el < 6) return certsyn("invalid certificate info sequence"); } c.version = 0; # set to default (v1) (ok, c.version) = parse_version(hd el); if(!ok) return certsyn("can't parse version"); if(c.version > 0) { el = tl el; if(len el < 6) break parse; } # serial number (ok, c.serial_number) = parse_sernum(hd el); if(!ok) return certsyn("can't parse serial number"); el = tl el; # signature algorithm (ok, c.sig) = parse_alg(hd el); if(!ok) return certsyn("can't parse sigalg"); el = tl el; # issuer (ok, c.issuer) = parse_name(hd el); if(!ok) return certsyn("can't parse issuer"); el = tl el; # validity evalidity := hd el; (ok, c.validity) = parse_validity(evalidity); if(!ok) return certsyn("can't parse validity"); el = tl el; # Subject (ok, c.subject) = parse_name(hd el); if(!ok) return certsyn("can't parse subject"); el = tl el; # SubjectPublicKeyInfo (ok, c.subject_pkinfo) = parse_pkinfo(hd el); if(!ok) return certsyn("can't parse subject pk info"); el = tl el; # OPTIONAL for v2 and v3, must be in order # issuer unique identifier if(c.version == 0 && el != nil) return certsyn("bad unique ID"); if(el != nil) { if(c.version < 1) # at least v2 return certsyn("invalid v1 cert"); (ok, c.issuer_uid) = parse_uid(hd el, 1); if(ok) el = tl el; } # subject unique identifier if(el != nil) { if(c.version < 1) # v2 or v3 return certsyn("invalid v1 cert"); (ok, c.issuer_uid) = parse_uid(hd el, 2); if(ok) el = tl el; } # extensions if(el != nil) { if(c.version < 2) # must be v3 return certsyn("invalid v1/v2 cert"); e : ref Elem; (ok, e) = is_context(hd el, 3); if (!ok) break parse; (ok, c.exts) = parse_extlist(e); if(!ok) return certsyn("can't parse extension list"); el = tl el; } # must be no more left if(el != nil) return certsyn("unexpected data at end"); return ("", c); } return ("certificate: syntax error", nil); } # [public] # a der encoding of certificate data; returns (error, nil) tuple in failure Certificate.encode(c: self ref Certificate): (string, array of byte) { pack: for(;;) { el: list of ref Elem; # always has a version packed e_version := pack_version(c.version); if(e_version == nil) break pack; el = e_version :: el; # serial number e_sernum := pack_sernum(c.serial_number); if(e_sernum == nil) break pack; el = e_sernum :: el; # algorithm e_sig := pack_alg(c.sig); if(e_sig == nil) break pack; el = e_sig :: el; # issuer e_issuer := pack_name(c.issuer); if(e_issuer == nil) break pack; el = e_issuer :: el; # validity e_validity := pack_validity(c.validity); if(e_validity == nil) break pack; el = e_validity :: el; # subject e_subject := pack_name(c.subject); if(e_subject == nil) break pack; el = e_subject :: el; # public key info e_pkinfo := pack_pkinfo(c.subject_pkinfo); if(e_pkinfo == nil) break pack; el = e_pkinfo :: el; # issuer unique identifier if(c.issuer_uid != nil) { e_issuer_uid := pack_uid(c.issuer_uid); if(e_issuer_uid == nil) break pack; el = e_issuer_uid :: el; } # subject unique identifier if(c.subject_uid != nil) { e_subject_uid := pack_uid(c.subject_uid); if(e_subject_uid == nil) break pack; el = e_subject_uid :: el; } # extensions if(c.exts != nil) { e_exts := pack_extlist(c.exts); if(e_exts == nil) break pack; el = e_exts :: el; } # SEQUENCE order is important lseq: list of ref Elem; while(el != nil) { lseq = (hd el) :: lseq; el = tl el; } all := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(lseq)); return asn1->encode(all); } return ("incompleted certificate; unable to pack", nil); } # [public] # converts content of a certificate as visible string Certificate.tostring(c: self ref Certificate): string { s := "\tTBS Certificate"; s += "\n\tVersion:\n\t\t" + string c.version; s += "\n\tSerialNumber:\n\t\t" + c.serial_number.iptostr(10); s += "\n\tSignature: " + c.sig.tostring(); s += "\n\tIssuer: " + c.issuer.tostring(); s += "\n\tValidity: " + c.validity.tostring("local"); s += "\n\tSubject: " + c.subject.tostring(); s += "\n\tSubjectPKInfo: " + c.subject_pkinfo.tostring(); s += "\n\tIssuerUID: " + bastr(c.issuer_uid); s += "\n\tSubjectUID: " + bastr(c.subject_uid); s += "\n\tExtensions: "; exts := c.exts; while(exts != nil) { s += "\t\t" + (hd exts).tostring(); exts = tl exts; } return s; } # [public] Certificate.is_expired(c: self ref Certificate, date: int): int { if(date > c.validity.not_after || date < c.validity.not_before) return 1; return 0; } # [private] # version is optional marked by explicit context tag 0; no version is # required if default version (v1) is used parse_version(e: ref Elem): (int, int) { ver := 0; (ans, ec) := is_context(e, 0); if(ans) { ok := 0; (ok, ver) = ec.is_int(); if(!ok || ver < 0 || ver > 2) return (0, -1); } return (1, ver); } # [private] pack_version(v: int): ref Elem { return ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(v)); } # [private] parse_sernum(e: ref Elem): (int, ref IPint) { (ok, a) := e.is_bigint(); if(ok) return (1, IPint.bebytestoip(a)); if(X509_DEBUG) log("parse_sernum: syntax error"); return (0, nil); } # [private] pack_sernum(sn: ref IPint): ref Elem { return ref Elem(Tag(Universal, INTEGER, 0), ref Value.BigInt(sn.iptobebytes())); } # [private] parse_alg(e: ref Elem): (int, ref AlgIdentifier) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok || el == nil) break parse; oid: ref Oid; (ok, oid) = (hd el).is_oid(); if(!ok) break parse; el = tl el; params: array of byte; if(el != nil) { # TODO: determine the object type based on oid # then parse params #unused: int; #(ok, unused, params) = (hd el).is_bitstring(); #if(!ok || unused || tl el != nil) # break parse; } return (1, ref AlgIdentifier(oid, params)); } if(X509_DEBUG) log("parse_alg: syntax error"); return (0, nil); } # [private] pack_alg(a: ref AlgIdentifier): ref Elem { if(a.oid != nil) { el: list of ref Elem; el = ref Elem(Tag(Universal, ASN1->OBJECT_ID, 0), ref Value.ObjId(a.oid)) :: nil; if(a.parameter != nil) { el = ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0, a.parameter) ) :: el; } return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } return nil; } # [private] parse_name(e: ref Elem): (int, ref Name) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok) break parse; lrd: list of ref RDName; while(el != nil) { rd: ref RDName; (ok, rd) = parse_rdname(hd el); if(!ok) break parse; lrd = rd :: lrd; el = tl el; } # SEQUENCE l: list of ref RDName; while(lrd != nil) { l = (hd lrd) :: l; lrd = tl lrd; } return (1, ref Name(l)); } if(X509_DEBUG) log("parse_name: syntax error"); return (0, nil); } # [private] pack_name(n: ref Name): ref Elem { el: list of ref Elem; lrd := n.rd_names; while(lrd != nil) { rd := pack_rdname(hd lrd); if(rd == nil) return nil; el = rd :: el; lrd = tl lrd; } # reverse order l: list of ref Elem; while(el != nil) { l = (hd el) :: l; el = tl el; } return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(l)); } # [private] parse_rdname(e: ref Elem): (int, ref RDName) { parse: for(;;) { (ok, el) := e.is_set(); # unordered if(!ok) break parse; lava: list of ref AVA; while(el != nil) { ava: ref AVA; (ok, ava) = parse_ava(hd el); if(!ok) break parse; lava = ava :: lava; el = tl el; } return (1, ref RDName(lava)); } if(X509_DEBUG) log("parse_rdname: syntax error"); return (0, nil); } # [private] pack_rdname(r: ref RDName): ref Elem { el: list of ref Elem; lava := r.avas; while(lava != nil) { ava := pack_ava(hd lava); if(ava == nil) return nil; el = ava :: el; lava = tl lava; } return ref Elem(Tag(Universal, ASN1->SET, 1), ref Value.Set(el)); } # [private] parse_ava(e: ref Elem): (int, ref AVA) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok || len el != 2) break parse; a := ref AVA; (ok, a.oid) = (hd el).is_oid(); if(!ok) break parse; el = tl el; (ok, a.value) = (hd el).is_string(); if(!ok) break parse; return (1, a); } if(X509_DEBUG) log("parse_ava: syntax error"); return (0, nil); } # [private] pack_ava(a: ref AVA): ref Elem { el: list of ref Elem; if(a.oid == nil || a.value == "") return nil; # Note: order is important el = ref Elem(Tag(Universal, ASN1->GeneralString, 0), ref Value.String(a.value)) :: el; el = ref Elem(Tag(Universal, ASN1->OBJECT_ID, 0), ref Value.ObjId(a.oid)) :: el; return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } # [private] parse_validity(e: ref Elem): (int, ref Validity) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok || len el != 2) break parse; v := ref Validity; (ok, v.not_before) = parse_time(hd el, UTCTime); if(!ok) break parse; el = tl el; (ok, v.not_after) = parse_time(hd el, UTCTime); if(!ok) break parse; return (1, v); } if(X509_DEBUG) log("parse_validity: syntax error"); return (0, nil); } # [private] # standard says only UTC Time allowed for TBS Certificate, but there is exception of # GeneralizedTime for CRL and Attribute Certificate. Parsing is based on format of # UTCTime, GeneralizedTime or undetermined (any int not UTCTime or GeneralizedTime). parse_time(e: ref Elem, format: int): (int, int) { parse: for(;;) { (ok, date) := e.is_time(); if(!ok) break parse; if(e.tag.num != UTCTime && e.tag.num != GeneralizedTime) break parse; if(format == UTCTime && e.tag.num != UTCTime) break parse; if(format == GeneralizedTime && e.tag.num != GeneralizedTime) break parse; t := decode_time(date, e.tag.num); if(t < 0) break parse; return (1, t); } if(X509_DEBUG) log("parse_time: syntax error"); return (0, -1); } # [private] # decode a BER encoded UTC or Generalized time into epoch (seconds since 1/1/1970 GMT) # UTC time format: YYMMDDhhmm[ss](Z|(+|-)hhmm) # Generalized time format: YYYYMMDDhhmm[ss.s(...)](Z|(+|-)hhmm[ss.s(...)) decode_time(date: string, format: int): int { time := ref Daytime->Tm; parse: for(;;) { i := 0; if(format == UTCTime) { if(len date < 11) break parse; time.year = get2(date, i); if(time.year < 0) break parse; if(time.year < 70) time.year += 100; i += 2; } else { if(len date < 13) break parse; time.year = get2(date, i); if(time.year-19 < 0) break parse; time.year = (time.year - 19)*100; i += 2; time.year += get2(date, i); i += 2; } time.mon = get2(date, i) - 1; if(time.mon < 0 || time.mon > 11) break parse; i += 2; time.mday = get2(date, i); if(time.mday < 1 || time.mday > 31) break parse; i += 2; time.hour = get2(date, i); if(time.hour < 0 || time.hour > 23) break parse; i += 2; time.min = get2(date, i); if(time.min < 0 || time.min > 59) break parse; i += 2; if(int date[i] >= '0' && int date[i] <= '9') { if(len date < i+3) break parse; time.sec = get2(date, i); if(time.sec < 0 || time.sec > 59) break parse; i += 2; if(format == GeneralizedTime) { if((len date < i+3) || int date[i++] != '.') break parse; # ignore rest ig := int date[i]; while(ig >= '0' && ig <= '9' && i++ < len date) { ig = int date[i]; } } } else { time.sec = 0; } zf := int date[i]; if(zf != 'Z' && zf != '+' && zf != '-') break parse; if(zf == 'Z') { if(len date != i+1) break parse; time.tzoff = 0; } else { if(len date < i + 3) break parse; time.tzoff = get2(date, i+1); if(time.tzoff < 0 || time.tzoff > 23) break parse; i += 2; min := get2(date, i); if(min < 0 || min > 59) break parse; i += 2; sec := 0; if(i != len date) { if(format == UTCTime || len date < i+4) break parse; sec = get2(date, i); i += 2; # ignore the rest } time.tzoff = (time.tzoff*60 + min)*60 + sec; if(zf == '-') time.tzoff = -time.tzoff; } return daytime->tm2epoch(time); } if(X509_DEBUG) log("decode_time: syntax error: " + sys->sprint("year=%d mon=%d mday=%d hour=%d min=%d, sec=%d", time.year, time.mon, time.mday, time.hour, time.min, time.sec)); return -1; } # [private] # pack as UTC time pack_validity(v: ref Validity): ref Elem { el: list of ref Elem; el = ref Elem( Tag(Universal, UTCTime, 0), ref Value.String(pack_time(v.not_before, UTCTime)) ) :: nil; el = ref Elem( Tag(Universal, UTCTime, 0), ref Value.String(pack_time(v.not_after, UTCTime)) ) :: el; return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } # [private] # Format must be either UTCTime or GeneralizedTime # TODO: convert to coordinate time pack_time(t: int, format: int): string { date := array [32] of byte; tm := daytime->gmt(t); i := 0; if(format == UTCTime) { i = put2(date, tm.year, i); } else { # GeneralizedTime i = put2(date, 19 + tm.year/100, i); i = put2(date, tm.year%100, i); } i = put2(date, tm.mon, i); i = put2(date, tm.mday, i); i = put2(date, tm.hour, i); i = put2(date, tm.min, i); if(tm.sec != 0) { if(format == UTCTime) i = put2(date, tm.sec, i); else { i = put2(date, tm.sec, i); date[i++] = byte '.'; date[i++] = byte 0; } } if(tm.tzoff == 0) { date[i++] = byte 'Z'; } else { off := tm.tzoff; if(tm.tzoff < 0) { off = -off; date[i++] = byte '-'; } else { date[i++] = byte '+'; } hoff := int (off/3600); moff := int ((off%3600)/60); soff := int ((off%3600)%60); i = put2(date, hoff, i); i = put2(date, moff, i); if(soff) { if(format == UTCTime) i = put2(date, soff, i); else { i = put2(date, soff, i); date[i++] = byte '.'; date[i++] = byte 0; } } } return string date[0:i]; } # [private] parse_pkinfo(e: ref Elem): (int, ref SubjectPKInfo) { parse: for(;;) { p := ref SubjectPKInfo; (ok, el) := e.is_seq(); if(!ok || len el != 2) break parse; (ok, p.alg_id) = parse_alg(hd el); if(!ok) break parse; unused: int; (ok, unused, p.subject_pk) = (hd tl el).is_bitstring(); if(!ok || unused != 0) break parse; return (1, p); } if(X509_DEBUG) log("parse_pkinfo: syntax error"); return (0, nil); } # [private] pack_pkinfo(p: ref SubjectPKInfo): ref Elem { el: list of ref Elem; # SEQUENCE order is important el = ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0, p.subject_pk) # 0 bits unused ? ) :: nil; el = pack_alg(p.alg_id) :: el; return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } # [private] parse_uid(e: ref Elem, num: int): (int, array of byte) { ok, unused : int; uid : array of byte; e2 : ref Elem; parse: for(;;) { (ok, e2) = is_context(e, num); if (!ok) break parse; e = e2; (ok, unused, uid) = e.is_bitstring(); # if(!ok || unused != 0) if(!ok) break parse; return (1, uid); } if(X509_DEBUG) log("parse_uid: syntax error"); return (0, nil); } # [private] pack_uid(u: array of byte): ref Elem { return ref Elem(Tag(Universal, ASN1->BIT_STRING, 0), ref Value.BitString(0,u)); } # [private] parse_extlist(e: ref Elem): (int, list of ref Extension) { parse: # dummy loop for breaking out of for(;;) { l: list of ref Extension; (ok, el) := e.is_seq(); if(!ok) break parse; while(el != nil) { ext := ref Extension; (ok, ext) = parse_extension(hd el); if(!ok) break parse; l = ext :: l; el = tl el; } # sort to order nl: list of ref Extension; while(l != nil) { nl = (hd l) :: nl; l = tl l; } return (1, nl); } if(X509_DEBUG) log("parse_extlist: syntax error"); return (0, nil); } # [private] pack_extlist(e: list of ref Extension): ref Elem { el: list of ref Elem; exts := e; while(exts != nil) { ext := pack_extension(hd exts); if(ext == nil) return nil; el = ext :: el; exts = tl exts; } # reverse order l: list of ref Elem; while(el != nil) { l = (hd el) :: l; el = tl el; } return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(l)); } # [private] # Require further parse to check oid if critical is set to TRUE (see parse_exts) parse_extension(e: ref Elem): (int, ref Extension) { parse: for(;;) { ext := ref Extension; (ok, el) := e.is_seq(); if(!ok) break parse; oid: ref Oid; (ok, oid) = (hd el).is_oid(); if(!ok) break parse; ext.oid = oid; el = tl el; # BOOLEAN DEFAULT FALSE (ok, ext.critical) = (hd el).is_int(); if(ok) el = tl el; else ext.critical = 0; if (len el != 1) { break parse; } (ok, ext.value) = (hd el).is_octetstring(); if(!ok) break parse; return (1, ext); } if(X509_DEBUG) log("parse_extension: syntax error"); return (0, nil); } # [private] pack_extension(e: ref Extension): ref Elem { el: list of ref Elem; if(e.oid == nil || (e.critical !=0 && e.critical != 1) || e.value == nil) return nil; # SEQUENCE order el = ref Elem(Tag(Universal, OCTET_STRING, 0), ref Value.Octets(e.value)) :: el; el = ref Elem(Tag(Universal, BOOLEAN, 0), ref Value.Bool(e.critical)) :: el; el = ref Elem(Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(e.oid)) :: el; return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } # [public] AlgIdentifier.tostring(a: self ref AlgIdentifier): string { return "\n\t\toid: " + a.oid.tostring() + "\n\t\twith parameter: "+ bastr(a.parameter); } # [public] Name.equal(a: self ref Name, b: ref Name): int { rda := a.rd_names; rdb := b.rd_names; if(len rda != len rdb) return 0; while(rda != nil && rdb != nil) { ok := (hd rda).equal(hd rdb); if(!ok) return 0; rda = tl rda; rdb = tl rdb; } return 1; } # [public] # The sequence of RelativeDistinguishedName's gives a sort of pathname, from most general to # most specific. Each element of the path can be one or more (but usually just one) # attribute-value pair, such as countryName="US". We'll just form a "postal-style" address # string by concatenating the elements from most specific to least specific, separated by commas. Name.tostring(a: self ref Name): string { path: string; rdn := a.rd_names; while(rdn != nil) { path += (hd rdn).tostring(); rdn = tl rdn; if(rdn != nil) path += ","; } return path; } # [public] # The allocation of distinguished names is the responsibility of the Naming Authorities. # Each user shall therefore trust the Naming Authorities not to issue duplicate distinguished # names. The comparison shall be unique one to one match but may not in the same order. RDName.equal(a: self ref RDName, b: ref RDName): int { if(len a.avas != len b.avas) return 0; aa := a.avas; ba := b.avas; while(aa != nil) { found:= 0; rest: list of ref AVA; while(ba != nil) { ok := (hd ba).equal(hd ba); if(!ok) rest = (hd aa) :: rest; else { if(found) return 0; found = 1; } ba = tl ba; } if(found == 0) return 0; ba = rest; aa = tl aa; } return 1; } # [public] RDName.tostring(a: self ref RDName): string { s: string; avas := a.avas; while(avas != nil) { s += (hd avas).tostring(); avas = tl avas; if(avas != nil) s += "-"; } return s; } # [public] # AVA are equal if they have the same type oid and value AVA.equal(a: self ref AVA, b: ref AVA): int { # TODO: need to match different encoding (T61String vs. IA5String) if(a.value != b.value) return 0; return oid_cmp(a.oid, b.oid); } # [public] AVA.tostring(a: self ref AVA): string { return a.value; } # [public] Validity.tostring(v: self ref Validity, format: string): string { s: string; if(format == "local") { s = "\n\t\tnot_before[local]: "; s += daytime->text(daytime->local(v.not_before)); s += "\n\t\tnot_after[local]: "; s += daytime->text(daytime->local(v.not_after)); } else if(format == "gmt") { s = "\n\t\tnot_before[gmt]: "; s += daytime->text(daytime->gmt(v.not_before)); s += "\n\t\tnot_after[gmt]: "; s += daytime->text(daytime->gmt(v.not_after)); } else s += "unknown format: " + format; return s; } # [public] SubjectPKInfo.getPublicKey(pkinfo: self ref SubjectPKInfo): (string, int, ref PublicKey) { parse: for(;;) { pk: ref PublicKey; id := asn1->oid_lookup(pkinfo.alg_id.oid, pkcs->objIdTab); case id { PKCS->id_pkcs_rsaEncryption or PKCS->id_pkcs_md2WithRSAEncryption or PKCS->id_pkcs_md4WithRSAEncryption or PKCS->id_pkcs_md5WithRSAEncryption => (err, k) := pkcs->decode_rsapubkey(pkinfo.subject_pk); if(err != nil) break parse; pk = ref PublicKey.RSA(k); PKCS->id_algorithm_shaWithDSS => (err, k) := pkcs->decode_dsspubkey(pkinfo.subject_pk); if(err != nil) break parse; pk = ref PublicKey.DSS(k); PKCS->id_pkcs_dhKeyAgreement => (err, k) := pkcs->decode_dhpubkey(pkinfo.subject_pk); if(err != nil) break parse; pk = ref PublicKey.DH(k); * => break parse; } return ("", id, pk); } return ("subject public key: syntax error", -1, nil); } # [public] SubjectPKInfo.tostring(pkinfo: self ref SubjectPKInfo): string { s := pkinfo.alg_id.tostring(); s += "\n\t\tencoded key: " + bastr(pkinfo.subject_pk); return s; } # [public] Extension.tostring(e: self ref Extension): string { s := "oid: " + e.oid.tostring(); s += "critical: "; if(e.critical) s += "true "; else s += "false "; s += bastr(e.value); return s; } ## Certificate PATH ## A list of certificates needed to allow a particular user to obtain ## the public key of another, is known as a certificate path. A ## certificate path logically forms an unbroken chain of trusted ## points in the DIT between two users wishing to authenticate. ## To establish a certification path between user A and user B using ## the Directory without any prior information, each CA may store ## one certificate and one reverse certificate designated as ## corresponding to its superior CA. # The ASN.1 data byte definitions for certificates and a certificate # path is # # Certificates ::= SEQUENCE { # userCertificate Certificate, # certificationPath ForwardCertificationPath OPTIONAL } # # ForwardCertificationPath ::= SEQUENCE OF CrossCertificates # CrossCertificates ::= SET OF Certificate # # [public] # Verify a decoded certificate chain in order of root to user. This is useful for # non_ASN.1 encoding of certificates, e.g. in SSL. Return (0, error string) if # verification failure or (1, "") if verification ok verify_certchain(cs: list of array of byte): (int, string) { lsc: list of (ref Signed, ref Certificate); l := cs; while(l != nil) { (err, s) := Signed.decode(hd l); if(err != "") return (0, err); c: ref Certificate; (err, c) = Certificate.decode(s.tobe_signed); if(err != "") return (0, err); lsc = (s, c) :: lsc; l = tl l; } # reverse order a: list of (ref Signed, ref Certificate); while(lsc != nil) { a = (hd lsc) :: a; lsc = tl lsc; } return verify_certpath(a); } # [private] # along certificate path; first certificate is root verify_certpath(sc: list of (ref Signed, ref Certificate)): (int, string) { # verify self-signed root certificate (s, c) := hd sc; # TODO: check root RDName with known CAs and using # external verification of root - Directory service (err, id, pk) := c.subject_pkinfo.getPublicKey(); if(err != "") return (0, err); if(!is_validtime(c.validity) || !c.issuer.equal(c.subject) || !s.verify(pk, 0)) # TODO: prototype verify(key, ref AlgIdentifier)? return (0, "verification failure"); sc = tl sc; while(sc != nil) { (ns, nc) := hd sc; # TODO: check critical flags of extension list # check alt names field (err, id, pk) = c.subject_pkinfo.getPublicKey(); if(err != "") return (0, err); if(!is_validtime(nc.validity) || !nc.issuer.equal(c.subject) || !ns.verify(pk, 0)) # TODO: move prototype as ? return (0, "verification failure"); (s, c) = (ns, nc); sc = tl sc; } return (1, ""); } # [public] is_validtime(validity: ref Validity): int { # a little more expensive but more accurate now := daytime->now(); # need some conversion here if(now < validity.not_before || now > validity.not_after) return 0; return 1; } is_validpair(): int { return 0; } ## Certificate Revocation List (CRL) ## ## A CRL is a time-stampted list identifying revoked certificates. It is signed by a ## Certificate Authority (CA) and made freely available in a public repository. ## ## Each revoked certificate is identified in a CRL by its certificate serial number. ## When a certificate-using system uses a certificate (e.g., for verifying a remote ## user's digital signature), that system not only checks the certificate signature ## and validity but also acquires a suitably-recent CRL and checks that the certificate ## serial number is not on that CRL. The meaning of "suitably-recent" may vary with ## local policy, but it usually means the most recently-issued CRL. A CA issues a new ## CRL on a regular periodic basis (e.g., hourly, daily, or weekly). Entries are added ## on CRLs as revocations occur, and an entry may be removed when the certificate ## expiration date is reached. # [public] CRL.decode(a: array of byte): (string, ref CRL) { parse: # break on error for(;;) { (err, all) := asn1->decode(a); if(err != "") break parse; c := ref CRL; # CRL must be a ASN1 sequence (ok, el) := all.is_seq(); if(!ok || len el < 3) break parse; c.version = 1; # set to default (v2) (ok, c.version) = parse_version(hd el); if(!ok) break parse; if(c.version < 0) { el = tl el; if(len el < 4) break parse; } # signature algorithm (ok, c.sig) = parse_alg(hd el); if(!ok) break parse; el = tl el; # issuer: who issues the CRL (ok, c.issuer) = parse_name(hd el); if(!ok) break parse; el = tl el; # this update (ok, c.this_update) = parse_time(hd el, UTCTime); if(!ok) break parse; el = tl el; # OPTIONAL, must be in order # next_update if(el != nil) { (ok, c.next_update) = parse_time(hd el, UTCTime); if(!ok) break parse; el = tl el; } # revoked certificates if(el != nil) { (ok, c.revoked_certs) = parse_revoked_certs(hd el); if(!ok) break parse; el = tl el; } # extensions if(el != nil) { (ok, c.exts) = parse_extlist(hd el); if(!ok) break parse; el = tl el; } # must be no more left if(el != nil) break parse; return ("", c); } return ("CRL: syntax error", nil); } # [public] CRL.encode(c: self ref CRL): (string, array of byte) { pack: for(;;) { el: list of ref Elem; # always has a version packed e_version := pack_version(c.version); if(e_version == nil) break pack; el = e_version :: el; # algorithm e_sig := pack_alg(c.sig); if(e_sig == nil) break pack; el = e_sig :: el; # crl issuer e_issuer := pack_name(c.issuer); if(e_issuer == nil) break pack; el = e_issuer :: el; # validity e_this_update := pack_time(c.this_update, UTCTime); if(e_this_update == nil) break pack; el = ref Elem( Tag(Universal, ASN1->UTCTime, 0), ref Value.String(e_this_update) ) :: el; # next crl update if(c.next_update != 0) { e_next_update := pack_time(c.next_update, UTCTime); if(e_next_update == nil) break pack; el = ref Elem( Tag(Universal, ASN1->UTCTime, 0), ref Value.String(e_next_update) ) :: el; } # revoked certificates if(c.revoked_certs != nil) { e_revoked_certs := pack_revoked_certs(c.revoked_certs); if(e_revoked_certs == nil) break pack; el = e_revoked_certs :: el; } # crl extensions if(c.exts != nil) { e_exts := pack_extlist(c.exts); if(e_exts == nil) break pack; el = e_exts :: el; } # compose all elements lseq: list of ref Elem; while(el != nil) { lseq = (hd el) :: lseq; el = tl el; } all := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(lseq)); (err, ret) := asn1->encode(all); if(err != "") break; return ("", ret); } return ("incompleted CRL; unable to pack", nil); } # [public] CRL.tostring(c: self ref CRL): string { s := "Certificate Revocation List (CRL)"; s += "\nVersion: " + string c.version; s += "\nSignature: " + c.sig.tostring(); s += "\nIssuer: " + c.issuer.tostring(); s += "\nThis Update: " + daytime->text(daytime->local(c.this_update)); s += "\nNext Update: " + daytime->text(daytime->local(c.next_update)); s += "\nRevoked Certificates: "; rcs := c.revoked_certs; while(rcs != nil) { s += "\t" + (hd rcs).tostring(); rcs = tl rcs; } s += "\nExtensions: "; exts := c.exts; while(exts != nil) { s += "\t" + (hd exts).tostring(); exts = tl exts; } return s; } # [public] CRL.is_revoked(c: self ref CRL, sn: ref IPint): int { es := c.revoked_certs; while(es != nil) { if(sn.eq((hd es).user_cert)) return 1; es = tl es; } return 0; } # [public] RevokedCert.tostring(rc: self ref RevokedCert): string { s := "Revoked Certificate"; if(rc.user_cert == nil) return s + " [Bad Format]\n"; s += "\nSerial Number: " + rc.user_cert.iptostr(10); if(rc.revoc_date != 0) s += "\nRevocation Date: " + daytime->text(daytime->local(rc.revoc_date)); if(rc.exts != nil) { exts := rc.exts; while(exts != nil) { s += "\t" + (hd exts).tostring(); exts = tl exts; } } return s; } # [private] parse_revoked_certs(e: ref Elem): (int, list of ref RevokedCert) { lc: list of ref RevokedCert; parse: for(;;) { (ok, el) := e.is_seq(); if(!ok) break parse; while(el != nil) { c: ref RevokedCert; (ok, c) = parse_revoked(hd el); if(!ok) break parse; lc = c :: lc; el = tl el; } return (1, lc); } return (0, nil); } # [private] pack_revoked_certs(r: list of ref RevokedCert): ref Elem { el: list of ref Elem; rs := r; while(rs != nil) { rc := pack_revoked(hd rs); if(rc == nil) return nil; el = rc :: el; rs = tl rs; } # reverse order l: list of ref Elem; while(el != nil) { l = (hd el) :: l; el = tl el; } return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(l)); } # [private] parse_revoked(e: ref Elem): (int, ref RevokedCert) { parse: for(;;) { c: ref RevokedCert; (ok, el) := e.is_seq(); if(!ok || len el < 2) break parse; uc: array of byte; (ok, uc) = (hd el).is_bigint(); if(!ok) break parse; c.user_cert = IPint.bebytestoip(uc); el = tl el; (ok, c.revoc_date) = parse_time(hd el, UTCTime); if(!ok) break parse; el = tl el; if(el != nil) { (ok, c.exts) = parse_extlist(hd el); if(!ok) break parse; } return (1, c); } return (0, nil); } # [private] pack_revoked(r: ref RevokedCert): ref Elem { el: list of ref Elem; if(r.exts != nil) { e_exts := pack_extlist(r.exts); if(e_exts == nil) return nil; el = e_exts :: el; } if(r.revoc_date != 0) { e_date := pack_time(r.revoc_date, UTCTime); if(e_date == nil) return nil; el = ref Elem( Tag(Universal, ASN1->UTCTime, 0), ref Value.String(e_date) ) :: el; } if(r.user_cert == nil) return nil; el = ref Elem(Tag(Universal, INTEGER, 0), ref Value.BigInt(r.user_cert.iptobebytes()) ) :: el; return ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); } ## The extensions field allows addition of new fields to the structure ## without modification to the ASN.1 definition. An extension field ## consists of an extension identifier, a criticality flag, and a ## canonical encoding of a data value of an ASN.1 type associated with ## the identified extension. For those extensions where ordering of ## individual extensions within the SEQUENCE is significant, the ## specification of those individual extensions shall include the rules ## for the significance of the ordering. When an implementation ## processing a certificate does not recognize an extension, if the ## criticality flag is FALSE, it may ignore that extension. If the ## criticality flag is TRUE, unrecognized extensions shall cause the ## structure to be considered invalid, i.e. in a certificate, an ## unrecognized critical extension would cause validation of a signature ## using that certificate to fail. # [public] cr_exts(es: list of ref Extension): list of ref Extension { cr: list of ref Extension; l := es; while(l != nil) { e := hd l; if(e.critical == 1) cr = e :: cr; l = tl l; } return cr; } # [public] noncr_exts(es: list of ref Extension): list of ref Extension { ncr: list of ref Extension; l := es; while(l != nil) { e := hd l; if(e.critical == 0) ncr = e :: ncr; l = tl l; } return ncr; } # [public] parse_exts(exts: list of ref Extension): (string, list of ref ExtClass) { ets: list of ref ExtClass; l := exts; while(l != nil) { ext := hd l; (err, et) := ExtClass.decode(ext); if(err != "") return (err, nil); ets = et :: ets; l = tl l; } lseq: list of ref ExtClass; while(ets != nil) { lseq = (hd ets) :: lseq; ets = tl ets; } return ("", lseq); } # [public] ExtClass.decode(ext: ref Extension): (string, ref ExtClass) { err: string; eclass: ref ExtClass; oid := asn1->oid_lookup(ext.oid, objIdTab); case oid { id_ce_authorityKeyIdentifier => (err, eclass) = decode_authorityKeyIdentifier(ext); if(err == "" && ext.critical == 1) { err = "authority key identifier: should be non-critical"; break; } id_ce_subjectKeyIdentifier => (err, eclass) = decode_subjectKeyIdentifier(ext); if(err != "" && ext.critical != 0) { err = "subject key identifier: should be non-critical"; break; } id_ce_basicConstraints => (err, eclass) = decode_basicConstraints(ext); if(err == "" && ext.critical != 1) { err = "basic constraints: should be critical"; break; } id_ce_keyUsage => (err, eclass) = decode_keyUsage(ext); if(err == "" && ext.critical != 1) { err = "key usage: should be critical"; break; } id_ce_privateKeyUsage => (err, eclass) = decode_privateKeyUsage(ext); if(err == "" && ext.critical != 0) { err = "private key usage: should be non-critical"; break; } id_ce_policyMapping => (err, eclass) = decode_policyMapping(ext); if(err == "" && ext.critical != 0) { err = "policy mapping: should be non-critical"; break; } id_ce_certificatePolicies => (err, eclass) = decode_certificatePolicies(ext); # either critical or non-critical id_ce_issuerAltName => n: list of ref GeneralName; (err, n) = decode_alias(ext); if(err == "") eclass = ref ExtClass.IssuerAltName(n); # either critical or non-critical id_ce_subjectAltName => n: list of ref GeneralName; (err, n) = decode_alias(ext); if(err == "") eclass = ref ExtClass.SubjectAltName(n); # either critical or non-critical id_ce_nameConstraints => (err, eclass) = decode_nameConstraints(ext); # either critical or non-critical id_ce_policyConstraints => (err, eclass) = decode_policyConstraints(ext); # either critical or non-critical id_ce_cRLNumber => (err, eclass) = decode_cRLNumber(ext); if(err == "" && ext.critical != 0) { err = "crl number: should be non-critical"; break; } id_ce_reasonCode => (err, eclass) = decode_reasonCode(ext); if(err == "" && ext.critical != 0) { err = "crl reason: should be non-critical"; break; } id_ce_instructionCode => (err, eclass) = decode_instructionCode(ext); if(err == "" && ext.critical != 0) { err = "instruction code: should be non-critical"; break; } id_ce_invalidityDate => (err, eclass) = decode_invalidityDate(ext); if(err == "" && ext.critical != 0) { err = "invalidity date: should be non-critical"; break; } id_ce_issuingDistributionPoint => (err, eclass) = decode_issuingDistributionPoint(ext); if(err == "" && ext.critical != 1) { err = "issuing distribution point: should be critical"; break; } id_ce_cRLDistributionPoint => (err, eclass) = decode_cRLDistributionPoint(ext); # either critical or non-critical id_ce_certificateIssuer => (err, eclass) = decode_certificateIssuer(ext); if(err == "" && ext.critical != 1) { err = "certificate issuer: should be critical"; break; } id_ce_deltaCRLIndicator => (err, eclass) = decode_deltaCRLIndicator(ext); if(err == "" && ext.critical != 1) { err = "delta crl indicator: should be critical"; break; } id_ce_subjectDirectoryAttributes => (err, eclass) = decode_subjectDirectoryAttributes(ext); if(ext.critical != 0) { err = "subject directory attributes should be non-critical"; break; } * => err = "unknown extension class"; } return (err, eclass); } # [public] ExtClass.encode(ec: self ref ExtClass, critical: int): ref Extension { ext: ref Extension; if(critical) ; # unused pick c := ec { AuthorityKeyIdentifier => (err, a) := encode_authorityKeyIdentifier(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_authorityKeyIdentifier], 0, a); SubjectKeyIdentifier => (err, a) := encode_subjectKeyIdentifier(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_subjectKeyIdentifier], 0, a); BasicConstraints => (err, a) := encode_basicConstraints(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_basicConstraints], 0, a); KeyUsage => (err, a) := encode_keyUsage(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_keyUsage], 0, a); PrivateKeyUsage => (err, a) := encode_privateKeyUsage(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_privateKeyUsage], 0, a); PolicyMapping => (err, a) := encode_policyMapping(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_policyMapping], 0, a); CertificatePolicies => (err, a) := encode_certificatePolicies(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_certificatePolicies], 0, a); IssuerAltName => (err, a) := encode_alias(c.alias); if(err == "") ext = ref Extension(ref objIdTab[id_ce_issuerAltName], 0, a); SubjectAltName => (err, a) := encode_alias(c.alias); if(err == "") ext = ref Extension(ref objIdTab[id_ce_subjectAltName], 0, a); NameConstraints => (err, a) := encode_nameConstraints(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_nameConstraints], 0, a); PolicyConstraints => (err, a) := encode_policyConstraints(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_policyConstraints], 0, a); CRLNumber => (err, a) := encode_cRLNumber(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_cRLNumber], 0, a); ReasonCode => (err, a) := encode_reasonCode(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_reasonCode], 0, a); InstructionCode => (err, a) := encode_instructionCode(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_instructionCode], 0, a); InvalidityDate => (err, a) := encode_invalidityDate(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_invalidityDate], 0, a); CRLDistributionPoint => (err, a) := encode_cRLDistributionPoint(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_cRLDistributionPoint], 0, a); IssuingDistributionPoint => (err, a) := encode_issuingDistributionPoint(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_issuingDistributionPoint], 0, a); CertificateIssuer => (err, a) := encode_certificateIssuer(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_certificateIssuer], 0, a); DeltaCRLIndicator => (err, a) := encode_deltaCRLIndicator(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_deltaCRLIndicator], 0, a); SubjectDirectoryAttributes => (err, a) := encode_subjectDirectoryAttributes(c); if(err == "") ext = ref Extension(ref objIdTab[id_ce_subjectDirectoryAttributes], 0, a); } return ext; } # [public] ExtClass.tostring(et: self ref ExtClass): string { s: string; pick t := et { AuthorityKeyIdentifier => s = "Authority Key Identifier: "; s += "\n\tid = " + bastr(t.id); s += "\n\tissuer = " + t.issuer.tostring(); s += "\n\tserial_number = " + bastr(t.serial_number.iptobebytes()); SubjectKeyIdentifier => s = "Subject Key Identifier "; s += "\n\tid = " + bastr(t.id); BasicConstraints => s = "Basic Constraints: "; s += "\n\tdepth = " + string t.depth; KeyUsage => s = "Key Usage: "; s += "\n\tusage = "; PrivateKeyUsage => s = "Private Key Usage: "; s += "\n\tusage = "; PolicyMapping => s = "Policy Mapping: "; pl := t.pairs; while(pl != nil) { (issuer_oid, subject_oid) := hd pl; s += "\n\t(" + issuer_oid.tostring() + ", " + subject_oid.tostring() + ")"; pl = tl pl; } CertificatePolicies => s = "Certificate Policies: "; pl := t.policies; while(pl != nil) { s += (hd pl).tostring(); pl = tl pl; } IssuerAltName => s = "Issuer Alt Name: "; al := t.alias; while(al != nil) { s += (hd al).tostring() + ","; al = tl al; } SubjectAltName => s = "Subject Alt Name: "; al := t.alias; while(al != nil) { s += (hd al).tostring() + ","; al = tl al; } NameConstraints => s = "Name Constraints: "; s += "\n\tpermitted = "; p := t.permitted; while(p != nil) { s += (hd p).tostring(); p = tl p; } s += "\n\texcluded = "; e := t.excluded; while(e != nil) { s += (hd e).tostring(); e = tl e; } PolicyConstraints => s = "Policy Constraints: "; s += "\n\trequire = " + string t.require; s += "\n\tinhibit = " + string t.inhibit; CRLNumber => s = "CRL Number: "; s += "\n\tcurrent crl number = " + string t.curr; ReasonCode => s = "Reason Code: "; s += "\n\tcode = "; InstructionCode => s = "Instruction Code: "; s += "\n\thold with oid = " + t.oid.tostring(); InvalidityDate => s = "Invalidity Date: "; s += "\n\tdate = " + daytime->text(daytime->local(t.date)); CRLDistributionPoint => s = "CRL Distribution Point: "; ps := t.ps; while(ps != nil) { s += (hd ps).tostring() + ","; ps = tl ps; } IssuingDistributionPoint => s = "Issuing Distribution Point: "; CertificateIssuer => s = "Certificate Issuer: "; DeltaCRLIndicator => s = "Delta CRL Indicator: "; SubjectDirectoryAttributes => s = "Subject Directory Attributes: "; * => s = "Unknown Extension: "; } return s; } # [private] decode_authorityKeyIdentifier(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; ak := ref ExtClass.AuthorityKeyIdentifier; e := hd el; (ok, e) = is_context(e, 0); if(ok) { (ok, ak.id) = e.is_octetstring(); if(!ok) break parse; el = tl el; } if(el != nil && len el != 2) break parse; e = hd el; (ok, e) = is_context(e, 1); if(!ok) break parse; (ok, ak.issuer) = parse_gname(e); if(!ok) break parse; e = hd tl el; (ok, e) = is_context(e, 2); if(!ok) break parse; (ok, ak.serial_number) = parse_sernum(e); if(!ok) break; return ("", ak); } return ("syntax error", nil); } # [private] encode_authorityKeyIdentifier(c: ref ExtClass.AuthorityKeyIdentifier): (string, array of byte) { el: list of ref Elem; if(c.serial_number != nil) { (ok, e) := pack_context( ref Elem( Tag(Universal, INTEGER, 0), ref Value.BigInt(c.serial_number.iptobebytes()) ), 2 ); if(!ok) return ("syntax error", nil); el = e :: nil; } if(c.issuer != nil) { (ok, e) := pack_gname(c.issuer); if(!ok) return ("authority key identifier: encoding error", nil); (ok, e) = pack_context(e, 1); if(!ok) return ("authority key identifier: encoding error", nil); el = e :: el; } if(c.id != nil) { (ok, e) := pack_context( ref Elem( Tag(Universal, OCTET_STRING, 0), ref Value.Octets(c.id) ), 0 ); if(!ok) return ("authority key identifier: encoding error", nil); el = e :: el; } return asn1->encode(ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el))); } # [private] decode_subjectKeyIdentifier(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, id) := all.is_octetstring(); if(!ok) break parse; return ("", ref ExtClass.SubjectKeyIdentifier(id)); } return ("subject key identifier: syntax error", nil); } # [private] encode_subjectKeyIdentifier(c: ref ExtClass.SubjectKeyIdentifier): (string, array of byte) { if(c.id == nil) return ("syntax error", nil); e := ref Elem(Tag(Universal, OCTET_STRING, 0), ref Value.Octets(c.id)); return asn1->encode(e); } # [private] decode_basicConstraints(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el != 2) break parse; ca: int; (ok, ca) = (hd el).is_int(); # boolean if(!ok || ca != 1) break parse; path: int; (ok, path) = (hd tl el).is_int(); # integer if(!ok || path < 0) break parse; return ("", ref ExtClass.BasicConstraints(path)); } return ("basic constraints: syntax error", nil); } # [private] encode_basicConstraints(c: ref ExtClass.BasicConstraints): (string, array of byte) { el: list of ref Elem; el = ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(c.depth)) :: nil; el = ref Elem(Tag(Universal, BOOLEAN, 0), ref Value.Bool(1)) :: el; e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_keyUsage(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { # assert bits can fit into a limbo int if(len ext.value > 4) break parse; return ("", ref ExtClass.KeyUsage(b4int(ext.value))); } return ("key usage: syntax error", nil); } # [private] encode_keyUsage(c: ref ExtClass.KeyUsage): (string, array of byte) { return ("", int4b(c.usage)); } # [private] decode_privateKeyUsage(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el < 1) # at least one exists break parse; v := ref Validity; e := hd el; (ok, e) = is_context(e, 0); if(ok) { (ok, v.not_before) = parse_time(e, GeneralizedTime); if(!ok) break parse; el = tl el; } if(el != nil) { e = hd el; (ok, e) = is_context(e, 1); if(!ok) break parse; (ok, v.not_after) = parse_time(e, GeneralizedTime); if(!ok) break parse; } return ("", ref ExtClass.PrivateKeyUsage(v)); } return ("private key usage: syntax error", nil); } # [private] encode_privateKeyUsage(c: ref ExtClass.PrivateKeyUsage): (string, array of byte) { el: list of ref Elem; e: ref Elem; ok := 1; p := c.period; if(p == nil) return ("encode private key usage: imcomplete data", nil); if(p.not_after > 0) { t := pack_time(p.not_after, GeneralizedTime); e = ref Elem(Tag(Universal, GeneralizedTime, 0), ref Value.String(t)); (ok, e) = pack_context(e, 1); if(!ok) return ("encode private key usage: illegal context", nil); el = e :: nil; } if(p.not_before > 0) { t := pack_time(p.not_before, GeneralizedTime); e = ref Elem(Tag(Universal, GeneralizedTime, 0), ref Value.String(t)); (ok, e) = pack_context(e, 0); if(!ok) return ("encode private key usage: illegal context", nil); el = e :: el; } e = ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_policyMapping(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; l_pm: list of (ref Oid, ref Oid); while(el != nil) { e_pm: list of ref Elem; (ok, e_pm) = (hd el).is_seq(); if(!ok || len e_pm != 2) break parse; idp, sdp: ref Oid; (ok, idp) = (hd e_pm).is_oid(); if(!ok) break parse; (ok, sdp) = (hd tl e_pm).is_oid(); if(!ok) break parse; l_pm = (idp, sdp) :: l_pm; } # reverse the order l: list of (ref Oid, ref Oid); while(l_pm != nil) { l = (hd l_pm) :: l; l_pm = tl l_pm; } return ("", ref ExtClass.PolicyMapping(l)); } return ("policy mapping: syntax error", nil); } # [private] encode_policyMapping(c: ref ExtClass.PolicyMapping): (string, array of byte) { el, pel: list of ref Elem; if(c.pairs == nil) return ("policy mapping: incomplete data", nil); pl := c.pairs; while(pl != nil) { (a, b) := hd pl; if(a == nil || b == nil) return ("policy mapping: incomplete data", nil); be := ref Elem(Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(b)); ae := ref Elem(Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(a)); pel = ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(ae::be::nil) ) :: pel; pl = tl pl; } while(pel != nil) { el = (hd pel) :: el; pel = tl pel; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_certificatePolicies(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; l_pi: list of ref PolicyInfo; while(el != nil) { e_pi: list of ref Elem; (ok, e_pi) = (hd el).is_seq(); if(!ok || len e_pi > 2 || len e_pi < 1) break parse; pi: ref PolicyInfo; (ok, pi.oid) = (hd e_pi).is_oid(); if(!ok) break parse; # get optional policy qualifier info e_pi = tl e_pi; if(e_pi != nil) { e_pq: list of ref Elem; (ok, e_pq) = (hd e_pi).is_seq(); if(!ok || len e_pq > 2 || len e_pq < 1) break parse; l_pq: list of ref PolicyQualifier; while(e_pq != nil) { pq: ref PolicyQualifier; (ok, pq.oid) = (hd e_pq).is_oid(); if(!ok || pq.oid == nil) break parse; # get optional value if(tl e_pq != nil) { (ok, pq.value) = (hd tl e_pq).is_octetstring(); if(!ok) break parse; } l_pq = pq :: l_pq; e_pq = tl e_pq; } # reverse the order while(l_pq != nil) { pi.qualifiers = (hd l_pq) :: pi.qualifiers; l_pq = tl l_pq; } } l_pi = pi :: l_pi; } # reverse the order l: list of ref PolicyInfo; while(l_pi != nil) { l = (hd l_pi) :: l; l_pi = tl l_pi; } return ("", ref ExtClass.CertificatePolicies(l)); } return ("certificate policies: syntax error", nil); } # [private] encode_certificatePolicies(c: ref ExtClass.CertificatePolicies): (string, array of byte) { el, pel: list of ref Elem; pl := c.policies; while(pl != nil) { p := hd pl; if(p.oid == nil) return ("certificate policies: incomplete data", nil); plseq: list of ref Elem; if(p.qualifiers != nil) { ql := p.qualifiers; qel, qlseq: list of ref Elem; while(ql != nil) { pq := hd ql; pqseq: list of ref Elem; if(pq.oid == nil) return ("certificate policies: incomplete data", nil); if(pq.value != nil) { pqseq = ref Elem( Tag(Universal, OCTET_STRING, 0), ref Value.Octets(pq.value) ) :: nil; } pqseq = ref Elem( Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(pq.oid) ) :: pqseq; qlseq = ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(pqseq) ) :: qlseq; ql = tl ql; } while(qlseq != nil) { qel = (hd qlseq) :: qel; qlseq = tl qlseq; } plseq = ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(qel) ) :: nil; } plseq = ref Elem( Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(p.oid) ) :: plseq; pel = ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(plseq) ) :: pel; pl = tl pl; } while(pel != nil) { el = (hd pel) :: el; pel = tl pel; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_alias(ext: ref Extension): (string, list of ref GeneralName) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; l_sa: list of ref GeneralName; while(el != nil) { gn: ref GeneralName; (ok, gn) = parse_gname(hd el); if(!ok) break parse; l_sa = gn :: l_sa; el = tl el; } # reverse order sa: list of ref GeneralName; while(l_sa != nil) { sa = (hd l_sa) :: sa; l_sa = tl l_sa; } return ("", sa); } return ("alias: syntax error", nil); } # [private] encode_alias(gl: list of ref GeneralName): (string, array of byte) { el, gel: list of ref Elem; while(gl != nil) { g := hd gl; (ok, e) := pack_gname(g); if(!ok) return ("alias: encoding error", nil); gel = e :: gel; gl = tl gl; } while(gel != nil) { el = (hd gel) :: el; gel = tl gel; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_subjectDirectoryAttributes(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; l_a: list of ref Attribute; while(el != nil) { a: ref Attribute; #(ok, a) = parse_attr(hd el); #if(!ok) # break parse; l_a = a :: l_a; el = tl el; } # reverse order as: list of ref Attribute; while(l_a != nil) { as = (hd l_a) :: as; l_a = tl l_a; } return ("", ref ExtClass.SubjectDirectoryAttributes(as)); } return ("subject directory attributes: syntax error", nil); } # [private] encode_subjectDirectoryAttributes(c: ref ExtClass.SubjectDirectoryAttributes) : (string, array of byte) { el, ael: list of ref Elem; al := c.attrs; while(al != nil) { (ok, e) := pack_attr(hd al); if(!ok) return ("subject directory attributes: encoding error", nil); ael = e :: ael; al = tl al; } while(ael != nil) { el = (hd ael) :: el; ael = tl ael; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_nameConstraints(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el < 1 || len el > 2) break parse; nc := ref ExtClass.NameConstraints; if(el != nil) { (ok, nc.permitted) = parse_gsubtrees(hd el); if(!ok || nc.permitted == nil) break parse; el = tl el; } if(el!= nil) { (ok, nc.excluded) = parse_gsubtrees(hd el); if(!ok || nc.excluded == nil) break parse; } return ("", nc); } return ("name constraints: syntax error", nil); } # [private] encode_nameConstraints(c: ref ExtClass.NameConstraints): (string, array of byte) { el: list of ref Elem; if(c.permitted == nil && c.excluded == nil) return ("name constraints: incomplete data", nil); if(c.excluded != nil) { (ok, e) := pack_gsubtrees(c.excluded); if(!ok) return ("name constraints: encoding error", nil); el = e :: el; } if(c.permitted != nil) { (ok, e) := pack_gsubtrees(c.permitted); if(!ok) return ("name constraints: encoding error", nil); el = e :: el; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] parse_gsubtrees(e: ref Elem): (int, list of ref GSubtree) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok) break parse; l, lgs: list of ref GSubtree; while(el != nil) { gs: ref GSubtree; (ok, gs) = parse_gsubtree(hd el); if(!ok) break parse; lgs = gs :: lgs; el = tl el; } while(lgs != nil) { l = (hd lgs) :: l; lgs = tl lgs; } return (1, l); } return (0, nil); } # [private] pack_gsubtrees(gs: list of ref GSubtree): (int, ref Elem) { el, l: list of ref Elem; while(gs != nil) { (ok, e) := pack_gsubtree(hd gs); if(!ok) return (0, nil); l = e :: l; } while(l != nil) { el = (hd l) :: el; l = tl l; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return (1, e); } # [private] parse_gsubtree(e: ref Elem): (int, ref GSubtree) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok || len el > 3 || len el < 2) break parse; gs := ref GSubtree; e = hd el; (ok, gs.base) = parse_gname(e); if(!ok) break parse; el = tl el; e = hd el; (ok, e) = is_context(e, 0); if(ok) { (ok, gs.min) = e.is_int(); if(!ok) break parse; el = tl el; } # get optional maximum base distance if(el != nil) { e = hd el; (ok, e) = is_context(e, 1); if(!ok) break parse; (ok, gs.max) = e.is_int(); if(!ok) break parse; } return (1, gs); } return (0, nil); } # [private] pack_gsubtree(g: ref GSubtree): (int, ref Elem) { el: list of ref Elem; ok := 1; e: ref Elem; if(g.base == nil) return (0, nil); if(g.max != 0) { e = ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(g.max)); (ok, e) = pack_context(e, 1); if(!ok) return (0, nil); el = e :: nil; } if(g.min != 0) { e = ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(g.min)); (ok, e) = pack_context(e, 0); if(!ok) return (0, nil); el = e :: el; } (ok, e) = pack_gname(g.base); if(!ok) return (0, nil); el = e :: el; e = ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return (1, e); } # [private] decode_policyConstraints(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el < 1 || len el > 2) break parse; pc := ref ExtClass.PolicyConstraints; e := hd el; (ok, e) = is_context(e, 0); if(ok) { (ok, pc.require) = e.is_int(); if(!ok) break parse; el = tl el; } if(el != nil) { e = hd el; (ok, e) = is_context(e, 1); if(!ok) break parse; (ok, pc.inhibit) = e.is_int(); if(!ok) break parse; } return ("", pc); } return ("policy constraints: syntax error", nil); } # [private] encode_policyConstraints(c: ref ExtClass.PolicyConstraints): (string, array of byte) { el: list of ref Elem; ok := 1; if(c.inhibit > 0) { e := ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(c.inhibit)); (ok, e) = pack_context(e, 1); if(!ok) return ("policy constraints: encoding error", nil); el = e :: nil; } if(c.require > 0) { e := ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(c.require)); (ok, e) = pack_context(e, 0); if(!ok) return ("policy constraints: encoding error", nil); el = e :: el; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_cRLNumber(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, n) := all.is_int(); # TODO: should be IPint if(!ok) break parse; return ("", ref ExtClass.CRLNumber(n)); } return ("crl number: syntax error", nil); } # [private] encode_cRLNumber(c: ref ExtClass.CRLNumber): (string, array of byte) { e := ref Elem(Tag(Universal, INTEGER, 0), ref Value.Int(c.curr)); return asn1->encode(e); } # [private] decode_reasonCode(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, un_used_bits, code) := all.is_bitstring(); if(!ok) break parse; # no harm to ignore unused bits if(len code > 4) break parse; return ("", ref ExtClass.ReasonCode(b4int(code))); } return ("crl reason: syntax error", nil); } # [private] encode_reasonCode(c: ref ExtClass.ReasonCode): (string, array of byte) { e := ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0, int4b(c.code)) ); return asn1->encode(e); } # [private] decode_instructionCode(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, code) := all.is_oid(); if(!ok) break parse; return ("", ref ExtClass.InstructionCode(code)); } return ("instruction code: syntax error", nil); } # [private] encode_instructionCode(c: ref ExtClass.InstructionCode): (string, array of byte) { e := ref Elem(Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(c.oid)); return asn1->encode(e); } # [private] decode_invalidityDate(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, date) := all.is_time(); if(!ok) break parse; t := decode_time(date, GeneralizedTime); if(t < 0) break parse; return ("", ref ExtClass.InvalidityDate(t)); } return ("", nil); } # [private] encode_invalidityDate(c: ref ExtClass.InvalidityDate): (string, array of byte) { e := ref Elem( Tag(Universal, GeneralizedTime, 0), ref Value.String(pack_time(c.date, GeneralizedTime)) ); return asn1->encode(e); } # [private] decode_cRLDistributionPoint(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el < 1) # Note: at least one break parse; l, dpl: list of ref DistrPoint; while(el != nil) { dp: ref DistrPoint; (ok, dp) = parse_distrpoint(hd el); if(!ok) break parse; dpl = dp :: dpl; } # reverse order while(dpl != nil) { l = (hd dpl) :: l; dpl = tl dpl; } return ("", ref ExtClass.CRLDistributionPoint(l)); } return ("crl distribution point: syntax error", nil); } # [private] encode_cRLDistributionPoint(c: ref ExtClass.CRLDistributionPoint): (string, array of byte) { el, l: list of ref Elem; dpl := c.ps; if(dpl == nil) # at lease one return ("crl distribution point: incomplete data error", nil); while(dpl != nil) { (ok, e) := pack_distrpoint(hd dpl); if(!ok) return ("crl distribution point: encoding error", nil); l = e :: l; } while(l != nil) { el = (hd l) :: el; l = tl l; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] parse_distrpoint(e: ref Elem): (int, ref DistrPoint) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok) break parse; if(!ok || len el > 3 || len el < 1) break parse; dp: ref DistrPoint; e = hd el; # get optional distribution point name (ok, e) = is_context(e, 0); if(ok) { (ok, dp.name) = parse_dpname(e); if(!ok) break parse; el = tl el; } # get optional reason flags if(el != nil) { e = hd el; (ok, e) = is_context(e, 1); if(ok) { unused_bits: int; reasons: array of byte; (ok, unused_bits, reasons) = e.is_bitstring(); if(!ok) break parse; # no harm to ignore unused bits if(len reasons > 4) break parse; dp.reasons = b4int(reasons); } el = tl el; } # get optional crl issuer if(el != nil) { e = hd el; (ok, e) = is_context(e, 2); if(!ok) break parse; (ok, dp.issuer) = parse_lgname(e); if(!ok) break parse; el = tl el; } # must be no more left if(el != nil) break parse; return (1, dp); } return (0, nil); } # [private] pack_distrpoint(dp: ref DistrPoint): (int, ref Elem) { el: list of ref Elem; if(dp.issuer != nil) { (ok, e) := pack_lgname(dp.issuer); if(!ok) return (0, nil); (ok, e) = pack_context(e, 2); if(!ok) return (0, nil); el = e :: nil; } if(dp.reasons != 0) { e := ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0, int4b(dp.reasons)) ); ok := 1; (ok, e) = pack_context(e, 1); if(!ok) return (0, nil); el = e :: el; } if(dp.name != nil) { (ok, e) := pack_dpname(dp.name); if(!ok) return (0, nil); (ok, e) = pack_context(e, 0); if(!ok) return (0, nil); el = e :: el; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return (1, e); } # [private] parse_dpname(e: ref Elem): (int, ref DistrPointName) { parse: for(;;) { # parse CHOICE ok := 0; (ok, e) = is_context(e, 0); if(ok) { lg: list of ref GeneralName; (ok, lg) = parse_lgname(e); if(!ok) break parse; return (1, ref DistrPointName(lg, nil)); } (ok, e) = is_context(e, 1); if(!ok) break parse; n: ref Name; (ok, n) = parse_name(e); if(!ok) break parse; return (1, ref DistrPointName(nil, n.rd_names)); } return (0, nil); } # [private] pack_dpname(dpn: ref DistrPointName): (int, ref Elem) { if(dpn.full_name != nil) { (ok, e) := pack_lgname(dpn.full_name); if(!ok) return (0, nil); return pack_context(e, 0); } if(dpn.rdname != nil) { rdn := dpn.rdname; el, l: list of ref Elem; while(rdn != nil) { l = pack_rdname(hd rdn) :: l; rdn = tl rdn; } while(l != nil) { el = (hd l) :: el; l = tl l; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return pack_context(e, 1); } return (0, nil); } # [private] decode_issuingDistributionPoint(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok || len el < 3 || len el > 5) break parse; ip := ref ExtClass.IssuingDistributionPoint; ae := hd el; # get optional distribution point name (ok, ae) = is_context(ae, 0); if(ok) { #(ok, ip.name) = parse_dpname(ae); if(!ok) break parse; el = tl el; } # get only contains user certs field if(el != nil) { ae = hd el; (ok, ae) = is_context(ae, 1); if(ok) { (ok, ip.only_usercerts) = ae.is_int(); # boolean if(!ok) break parse; } el = tl el; } # get only contains ca certs field if(el != nil) { ae = hd el; (ok, ae) = is_context(ae, 2); if(ok) { (ok, ip.only_cacerts) = ae.is_int(); # boolean if(!ok) break parse; } el = tl el; } # get optioinal only some reasons if(el != nil) { ae = hd el; (ok, ae) = is_context(ae, 3); if(ok) { reasons: array of byte; unused_bits: int; (ok, unused_bits, reasons) = ae.is_bitstring(); if(!ok || len reasons > 4) break parse; ip.only_reasons = b4int(reasons); } el = tl el; } # get indirect crl field if(el != nil) { ae = hd el; (ok, ae) = is_context(ae, 4); if(!ok) break parse; (ok, ip.indirect_crl) = ae.is_int(); # boolean if(!ok) break parse; el = tl el; } # must be no more left if(el != nil) break parse; return ("", ip); } return ("issuing distribution point: syntax error", nil); } # [private] encode_issuingDistributionPoint(c: ref ExtClass.IssuingDistributionPoint) : (string, array of byte) { el: list of ref Elem; ok := 1; if(c.indirect_crl != 0) { # no encode for DEFAULT e := ref Elem( Tag(Universal, BOOLEAN, 0), ref Value.Bool(c.indirect_crl) ); (ok, e) = pack_context(e, 4); if(!ok) return ("issuing distribution point: encoding error", nil); el = e :: el; } if(c.only_reasons != 0) { e := ref Elem( Tag(Universal, BIT_STRING, 0), ref Value.BitString(0, int4b(c.only_reasons)) ); (ok, e) = pack_context(e, 3); if(!ok) return ("issuing distribution point: encoding error", nil); el = e :: el; } if(c.only_cacerts != 0) { e := ref Elem( Tag(Universal, BOOLEAN, 0), ref Value.Bool(c.only_cacerts) ); (ok, e) = pack_context(e, 2); if(!ok) return ("issuing distribution point: encoding error", nil); el = e :: el; } if(c.only_usercerts != 0) { e := ref Elem( Tag(Universal, BOOLEAN, 0), ref Value.Bool(c.only_usercerts) ); (ok, e) = pack_context(e, 1); if(!ok) return ("issuing distribution point: encoding error", nil); el = e :: el; } if(c.name != nil) { e: ref Elem; (ok, e) = pack_dpname(c.name); if(!ok) return ("issuing distribution point: encoding error", nil); (ok, e) = pack_context(e, 0); if(!ok) return ("issuing distribution point: encoding error", nil); el = e :: el; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_certificateIssuer(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, el) := all.is_seq(); if(!ok) break parse; gl, gnl: list of ref GeneralName; while(el != nil) { g: ref GeneralName; (ok, g) = parse_gname(hd el); if(!ok) break parse; gnl = g :: gnl; el = tl el; } while(gnl != nil) { gl = (hd gnl) :: gl; gnl = tl gnl; } return ("", ref ExtClass.CertificateIssuer(gl)); } return ("certificate issuer: syntax error", nil); } # [private] encode_certificateIssuer(c: ref ExtClass.CertificateIssuer): (string, array of byte) { el, nel: list of ref Elem; ns := c.names; while(ns != nil) { (ok, e) := pack_gname(hd ns); if(!ok) return ("certificate issuer: encoding error", nil); nel = e :: nel; ns = tl ns; } while(nel != nil) { el = (hd nel) :: el; nel = tl nel; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return asn1->encode(e); } # [private] decode_deltaCRLIndicator(ext: ref Extension): (string, ref ExtClass) { parse: for(;;) { (err, all) := asn1->decode(ext.value); if(err != "") break parse; (ok, b) := all.is_bigint(); if(!ok) break parse; return ("", ref ExtClass.DeltaCRLIndicator(IPint.bebytestoip(b))); } return ("delta crl number: syntax error", nil); } # [private] encode_deltaCRLIndicator(c: ref ExtClass.DeltaCRLIndicator): (string, array of byte) { e := ref Elem( Tag(Universal, INTEGER, 0), ref Value.BigInt(c.number.iptobebytes()) ); return asn1->encode(e); } # [public] GeneralName.tostring(gn: self ref GeneralName): string { s: string; pick g := gn { otherName => s = "other name: " + g.str; rfc822Name => s = "rfc822 name: " + g.str; dNSName => s = "dns name: " + g.str; x400Address => s = "x400 address: " + g.str; uniformResourceIdentifier => s = "url: " + g.str; iPAddress => s = "ip address: " + bastr(g.ip); registeredID => s = "oid: " + g.oid.tostring(); ediPartyName => s = "edi party name: "; s += "\n\tname assigner is " + g.nameAssigner.tostring(); s += "\n\tparty name is " + g.partyName.tostring(); directoryName => s = "directory name: " + g.dir.tostring(); } return s; } # [public] PolicyInfo.tostring(pi: self ref PolicyInfo): string { s := "oid: " + pi.oid.tostring(); s += "qualifiers: "; ql := pi.qualifiers; while(ql != nil) { s += (hd ql).tostring(); ql = tl ql; } return s; } # [public] PolicyQualifier.tostring(pq: self ref PolicyQualifier): string { s := "oid: " + pq.oid.tostring(); s += "value: " + bastr(pq.value); return s; } # [public] GSubtree.tostring(gs: self ref GSubtree): string { s := "base: " + gs.base.tostring(); s += "range: " + string gs.min + "-" + string gs.max; return s; } # [public] DistrPoint.tostring(dp: self ref DistrPoint): string { s := "Distribution Point: "; s += "\n\tname = "; d := dp.name; if(d.full_name != nil) { f := d.full_name; while(f != nil) { s += (hd f).tostring() + ","; f = tl f; } } else { r := d.rdname; while(r != nil) { s += (hd r).tostring() + ","; r = tl r; } } s += "\n\treasons = " + string dp.reasons; s += "\n\tissuer = "; gl := dp.issuer; while(gl != nil) { s += (hd gl).tostring() + ","; gl = tl gl; } return s; } # [private] is_context(e: ref Elem, num: int): (int, ref Elem) { if(e.tag.class == ASN1->Context && e.tag.num == num) { pick v := e.val { Octets => (err, all) := asn1->decode(v.bytes); if(err == "") return (1, all); } } return (0, nil); } # [private] pack_context(e: ref Elem, num: int): (int, ref Elem) { (err, b) := asn1->encode(e); if(err == "") return (1, ref Elem(Tag(Context, num, 0), ref Value.Octets(b))); return (0, nil); } # [private] parse_lgname(e: ref Elem): (int, list of ref GeneralName) { parse: for(;;) { (ok, el) := e.is_seq(); if(!ok) break parse; l, lg: list of ref GeneralName; while(el != nil) { g: ref GeneralName; (ok, g) = parse_gname(hd el); if(!ok) break parse; lg = g :: lg; el = tl el; } while(lg != nil) { l = (hd lg) :: l; lg = tl lg; } return (1, l); } return (0, nil); } # [private] pack_lgname(lg: list of ref GeneralName): (int, ref Elem) { el, gel: list of ref Elem; while(lg != nil) { (ok, e) := pack_gname(hd lg); if(!ok) return (0, nil); gel = e :: gel; lg = tl lg; } while(gel != nil) { el = (hd gel) :: el; gel = tl gel; } e := ref Elem(Tag(Universal, SEQUENCE, 1), ref Value.Seq(el)); return (1, e); } # [private] parse_gname(e: ref Elem): (int, ref GeneralName) { parse: for(;;) { g: ref GeneralName; ok := 1; case e.tag.num { 0 => (ok, e) = is_context(e, 0); if(!ok) break parse; str: string; (ok, str) = e.is_string(); if(!ok) break parse; g = ref GeneralName.otherName(str); 1 => (ok, e) = is_context(e, 1); if(!ok) break parse; str: string; (ok, str) = e.is_string(); if(!ok) break parse; g = ref GeneralName.rfc822Name(str); 2 => (ok, e) = is_context(e, 2); if(!ok) break parse; str: string; (ok, str) = e.is_string(); if(!ok) break parse; g = ref GeneralName.dNSName(str); 3 => (ok, e) = is_context(e, 3); if(!ok) break parse; str: string; (ok, str) = e.is_string(); if(!ok) break parse; g = ref GeneralName.x400Address(str); 4 => (ok, e) = is_context(e, 4); if(!ok) break parse; dir: ref Name; (ok, dir) = parse_name(e); if(!ok) break parse; g = ref GeneralName.directoryName(dir); 5 => (ok, e) = is_context(e, 5); if(!ok) break parse; el: list of ref Elem; (ok, el) = e.is_seq(); if(!ok || len el < 1 || len el > 3) break parse; na, pn: ref Name; (ok, e) = is_context(hd el, 0); if(ok) { (ok, na) = parse_name(e); if(!ok) break parse; el = tl el; } if(el != nil) { (ok, e) = is_context(hd el, 1); if(!ok) break parse; (ok, pn) = parse_name(e); if(!ok) break parse; } g = ref GeneralName.ediPartyName(na, pn); 6 => (ok, e) = is_context(e, 6); if(!ok) break parse; str: string; (ok, str) = e.is_string(); if(!ok) break parse; g = ref GeneralName.uniformResourceIdentifier(str); 7 => (ok, e) = is_context(e, 7); if(!ok) break parse; ip: array of byte; (ok, ip) = e.is_octetstring(); if(!ok) break parse; g = ref GeneralName.iPAddress(ip); 8 => (ok, e) = is_context(e, 8); if(!ok) break parse; oid: ref Oid; (ok, oid) = e.is_oid(); if(!ok) break parse; g = ref GeneralName.registeredID(oid); * => break parse; } return (1, g); } return (0, nil); } # [private] pack_gname(gn: ref GeneralName): (int, ref Elem) { e: ref Elem; ok := 1; pick g := gn { otherName => e = ref Elem( Tag(Universal, GeneralString, 0), ref Value.String(g.str) ); (ok, e) = pack_context(e, 0); if(!ok) return (0, nil); rfc822Name => e = ref Elem( Tag(Universal, IA5String, 0), ref Value.String(g.str) ); (ok, e) = pack_context(e, 1); if(!ok) return (0, nil); dNSName => e = ref Elem( Tag(Universal, IA5String, 0), ref Value.String(g.str) ); (ok, e) = pack_context(e, 2); if(!ok) return (0, nil); x400Address => e = ref Elem( Tag(Universal, GeneralString, 0), ref Value.String(g.str) ); (ok, e) = pack_context(e, 3); if(!ok) return (0, nil); uniformResourceIdentifier => e = ref Elem( Tag(Universal, GeneralString, 0), ref Value.String(g.str) ); (ok, e) = pack_context(e, 6); if(!ok) return (0, nil); iPAddress => e = ref Elem( Tag(Universal, OCTET_STRING, 0), ref Value.Octets(g.ip) ); (ok, e) = pack_context(e, 7); if(!ok) return (0, nil); registeredID => e = ref Elem( Tag(Universal, OBJECT_ID, 0), ref Value.ObjId(g.oid) ); (ok, e) = pack_context(e, 8); if(!ok) return (0, nil); ediPartyName => el: list of ref Elem; if(g.partyName != nil) { e = pack_name(g.partyName); (ok, e) = pack_context(e, 1); if(!ok) return (0, nil); el = e :: nil; } if(g.nameAssigner != nil) { e = pack_name(g.nameAssigner); (ok, e) = pack_context(e, 0); if(!ok) return (0, nil); el = e :: el; } e = ref Elem( Tag(Universal, SEQUENCE, 1), ref Value.Seq(el) ); (ok, e) = pack_context(e, 5); if(!ok) return (0, nil); directoryName => e = pack_name(g.dir); (ok, e) = pack_context(e, 4); if(!ok) return (0, nil); } return (1, e); } # [private] # convert at most 4 bytes to int, len buf must be less than 4 b4int(buf: array of byte): int { val := 0; for(i := 0; i < len buf; i++) val = (val << 8) | (int buf[i]); return val; } # [private] int4b(value: int): array of byte { n := 4; buf := array [n] of byte; while(n--) { buf[n] = byte value; value >>= 8; } return buf; } # [private] oid_cmp(a, b: ref Oid): int { na := len a.nums; nb := len b.nums; if(na != nb) return 0; for(i := 0; i < na; i++) { if(a.nums[i] != b.nums[i]) return 0; } return 1; } # [private] # decode two bytes into an integer [0-99] # return -1 for an invalid encoding get2(a: string, i: int): int { a0 := int a[i]; a1 := int a[i+1]; if(a0 < '0' || a0 > '9' || a1 < '0' || a1 > '9') return -1; return (a0 - '0')*10 + a1 - '0'; } # [private] # encode an integer [0-99] into two bytes put2(a: array of byte, n, i: int): int { a[i] = byte (n/10 + '0'); a[i+1] = byte (n%10 + '0'); return i+2; } # [private] bastr(a: array of byte) : string { ans := ""; for(i := 0; i < len a; i++) { if(i < len a - 1 && i%10 == 0) ans += "\n\t\t"; ans += sys->sprint("%2x ", int a[i]); } return ans; } # [private] parse_attr(nil: ref Elem): (int, ref Attribute) { return (0, nil); } # [private] pack_attr(nil: ref Attribute): (int, ref Elem) { return (0, nil); }