Browse OpenSSL punycode specs (2 of 19)
Proofs / OpenSSL punycode / Any input
rj_decode_invalid
Input with a byte that RFC 3492 6.2 says to fail on is refused (0, length unchanged): a non-ASCII byte before the last -, or a byte after it that is neither a letter nor a digit.
- spec
- 34 lines of C
- with its headers
- 86 lines
- status
- Proved
- 2 of 19
On this page
The spec
The spec is the C program harness/rj_decode_invalid.c, 34 lines, shown whole as it is in the repository at 7556530. It includes harness/laws_common.h (52 lines). Its first comment states the property in full, with every bound.
// Law rj_decode_invalid: ossl_punycode_decode fails where RFC 3492 6.2 says to fail on an octet. For any input (any
// octets, any length the allocator provides) and any capacity (any unsigned int), with an array of exactly that many
// elements holding any values: it returns 0, with *pout_length unchanged, when an octet before the last '-' is not
// basic (0x80 or more), or when an octet of the deltas (after the last '-'; all octets when there is no '-' or it is
// the first one) is neither a letter nor a digit, the octets that have a digit-value (RFC 3492 5).
#include "laws_common.h"
int main(void) {
// Choose the inputs: any octets, any capacity, any initial contents of the array
size_t len = upto(PTRDIFF_MAX);
unsigned char *input = any_bytes(len);
unsigned int cap = nondet_u32();
unsigned int *out = any_uints(cap);
if (input == NULL || out == NULL)
return 0;
// RFC 3492 6.2: "consume all code points before the last delimiter (if there is one) and copy them to output,
// fail on any non-basic code point; if more than zero code points were consumed then consume one more (which will
// be the last delimiter)", then for the deltas: "let digit = the code point's digit-value, fail if it has none"
size_t literal = last_delimiter(input, len);
size_t deltas = literal > 0 ? literal + 1 : 0; // where the deltas start
int invalid = 0;
for (size_t i = 0; i < len; i++) {
unsigned char c = input[i];
int digit = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9');
if ((i < literal && c >= 0x80) || (i >= deltas && !digit))
invalid = 1;
}
unsigned int count = cap;
int r = ossl_punycode_decode((const char *) input, len, out, &count);
// Check
if (invalid)
gp_assert(r == 0 && count == cap);
return 0;
}harness/laws_common.h, 52 lines
// laws_common.h: trivial helpers shared by the short laws (each law includes it once). No models, no algorithms.
#include <stdint.h>
#include <stdlib.h>
#include "quickproof.h"
#include "crypto/punycode.h" // ossl_punycode_decode, ossl_a2ulabel
// OpenSSL's allocator in this build (patch/shim/ossl_shim.c): set to 1 when CRYPTO_zalloc fails (malloc may fail at
// any call in the theorems), and the number of its blocks not freed yet.
extern int ossl_shim_zalloc_failed;
extern long ossl_shim_live;
static size_t upto(size_t max) { // any value from 0 to max
size_t value = nondet_size();
return value < max ? value : max;
}
static unsigned char *any_bytes(size_t n) { // a new object of n arbitrary bytes (NULL if malloc fails)
unsigned char *bytes = malloc(n);
if (bytes != NULL)
nondet_bytes(bytes, n);
return bytes;
}
static unsigned int *any_uints(size_t n) { // a new array of n arbitrary unsigned ints (NULL if malloc fails)
unsigned int *values = malloc(n * sizeof(unsigned int));
for (size_t i = 0; values != NULL && i < n; i++)
values[i] = nondet_u32();
return values;
}
static unsigned char *copy_of(const unsigned char *source, size_t n) { // a new object holding source[0..n-1]
if (source == NULL) // (NULL if source is or malloc fails)
return NULL;
unsigned char *copy = malloc(n);
for (size_t i = 0; copy != NULL && i < n; i++)
copy[i] = source[i];
return copy;
}
static int bytes_eq(const unsigned char *a, const unsigned char *b, size_t n) { // a[0..n-1] == b[0..n-1]
for (size_t i = 0; i < n; i++)
if (a[i] != b[i])
return 0;
return 1;
}
static int uints_eq(const unsigned int *a, const unsigned int *b, size_t n) { // a[0..n-1] == b[0..n-1]
for (size_t i = 0; i < n; i++)
if (a[i] != b[i])
return 0;
return 1;
}
static size_t last_delimiter(const unsigned char *s, size_t n) { // the position of the last '-', 0 if none
size_t last = 0;
for (size_t i = 0; i < n; i++)
if (s[i] == '-')
last = i;
return last;
}The theorem
QuickProof generated this statement from the spec, in src/contracts/rj_decode_invalid.v:
Theorem rj_decode_invalid : harness_safe whole_prog.src/contracts/laws.v states it on the spec's own program, whole_prog (the spec linked with the code under test), with its proof:
Theorem rj_decode_invalid : harness_safe OpensslPunycode.contracts.rj_decode_invalid.whole_prog.
Proof. exact (proj1 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 (proj2 OpensslPunycode.contracts.suite.suite))))))))))))))). Qed.Read as a statement about runs, it says that no run of the program has undefined behaviour or a failing check, for every value the spec can draw. That reading rests on VST's adequacy theorem, which is not yet instantiated in Rocq (formerly Coq) for QuickProof's environment.
The C files (units) its program links
crypto/punycode.cpatch/units/packet_ext.cpatch/shim/ossl_shim.cquickproof/libc/libc.c
What it leaves out
- What the first comment of the spec excludes, and its bounds.
- Like every spec of this proof: termination (a run that never returns is not a counterexample), one thread, and binaries built by a compiler (the theorem is about the code as CompCert defines C for x86-64, in a release build, compiled against a small header shim instead of OpenSSL's generated headers).
- The rest of OpenSSL: only
crypto/punycode.cand the parts ofcrypto/packet.cit reaches are code under test.
The summary page says what the proof as a whole covers.
How it was proved
AI agents wrote the proof, and Rocq checks it. qp verify passes on this repository: this statement is the one generated from the spec at the contract commit, and its proof uses only Rocq's standard axioms and VST's abstract malloc library.