secp256k1android/libs/secp256k1-cxx/secp256k1-cxx.cpp
static int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char* input, size_t inputlen)
{
    size_t rpos, rlen, spos, slen;
    size_t pos = 0;
    size_t lenbyte;
    unsigned char tmpsig[64] = { 0 };
    int overflow = 0;

    /* Hack to initialize sig with a correctly-parsed but invalid signature. */
    secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);

    /* Sequence tag byte */
    if (pos == inputlen || input[pos] != 0x30) {
        return 0;
    }
    pos++;

    /* Sequence length bytes */
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        pos += lenbyte;
    }

    /* Integer tag byte for R */
    if (pos == inputlen || input[pos] != 0x02) {
        return 0;
    }
    pos++;

    /* Integer length for R */
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        while (lenbyte > 0 && input[pos] == 0) {
            pos++;
            lenbyte--;
        }
        static_assert(sizeof(size_t) >= 4, "size_t too small");
        if (lenbyte >= 4) {
            return 0;
        }
        rlen = 0;
        while (lenbyte > 0) {
            rlen = (rlen << 8) + input[pos];
            pos++;
            lenbyte--;
        }
    } else {
        rlen = lenbyte;
    }
    if (rlen > inputlen - pos) {
        return 0;
    }
    rpos = pos;
    pos += rlen;

    /* Integer tag byte for S */
    if (pos == inputlen || input[pos] != 0x02) {
        return 0;
    }
    pos++;

    /* Integer length for S */
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        while (lenbyte > 0 && input[pos] == 0) {
            pos++;
            lenbyte--;
        }
        static_assert(sizeof(size_t) >= 4, "size_t too small");
        if (lenbyte >= 4) {
            return 0;
        }
        slen = 0;
        while (lenbyte > 0) {
            slen = (slen << 8) + input[pos];
            pos++;
            lenbyte--;
        }
    } else {
        slen = lenbyte;
    }
    if (slen > inputlen - pos) {
        return 0;
    }
    spos = pos;

    /* Ignore leading zeroes in R */
    while (rlen > 0 && input[rpos] == 0) {
        rlen--;
        rpos++;
    }
    /* Copy R value */
    if (rlen > 32) {
        overflow = 1;
    } else {
        memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
    }

    /* Ignore leading zeroes in S */
    while (slen > 0 && input[spos] == 0) {
        slen--;
        spos++;
    }
    /* Copy S value */
    if (slen > 32) {
        overflow = 1;
    } else {
        memcpy(tmpsig + 64 - slen, input + spos, slen);
    }

    if (!overflow) {
        overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
    }
    if (overflow) {
        /* Overwrite the result again with a correctly-parsed but invalid
           signature if parsing failed. */
        memset(tmpsig, 0, 64);
        secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
    }
    return 1;
}
/** This function is taken from the libsecp256k1 distribution and implements
 *  DER parsing for ECDSA signatures, while supporting an arbitrary subset of
 *  format violations.
 *
 *  Supported violations include negative integers, excessive padding, garbage
 *  at the end, and overly long length descriptors. This is safe to use in
 *  Bitcoin because since the activation of BIP66, signatures are verified to be
 *  strict DER before being passed to this module, and we know it supports all
 *  violations present in the blockchain before that point.
 */
This function is taken from the libsecp256k1 distribution and implements
DER parsing for ECDSA signatures, while supporting an arbitrary subset of
format violations.

Supported violations include negative integers, excessive padding, garbage
at the end, and overly long length descriptors. This is safe to use in
Bitcoin because since the activation of BIP66, signatures are verified to be
strict DER before being passed to this module, and we know it supports all
violations present in the blockchain before that point.
This function is taken from the libsecp256k1 distribution and implements DER parsing for ECDSA signatures while supporting an arbitrary subset of format violations . Supported violations include negative integers excessive padding garbage at the end and overly long length descriptors . This is safe to use in Bitcoin because since the activation of BIP66 signatures are verified to be strict DER before being passed to this module and we know it supports all violations present in the blockchain before that point .
static int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k1_ecdsa_signature* sig, const unsigned char* input, size_t inputlen)
{
    size_t rpos, rlen, spos, slen;
    size_t pos = 0;
    size_t lenbyte;
    unsigned char tmpsig[64] = { 0 };
    int overflow = 0;
    secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
    if (pos == inputlen || input[pos] != 0x30) {
        return 0;
    }
    pos++;
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        pos += lenbyte;
    }
    if (pos == inputlen || input[pos] != 0x02) {
        return 0;
    }
    pos++;
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        while (lenbyte > 0 && input[pos] == 0) {
            pos++;
            lenbyte--;
        }
        static_assert(sizeof(size_t) >= 4, "size_t too small");
        if (lenbyte >= 4) {
            return 0;
        }
        rlen = 0;
        while (lenbyte > 0) {
            rlen = (rlen << 8) + input[pos];
            pos++;
            lenbyte--;
        }
    } else {
        rlen = lenbyte;
    }
    if (rlen > inputlen - pos) {
        return 0;
    }
    rpos = pos;
    pos += rlen;
    if (pos == inputlen || input[pos] != 0x02) {
        return 0;
    }
    pos++;
    if (pos == inputlen) {
        return 0;
    }
    lenbyte = input[pos++];
    if (lenbyte & 0x80) {
        lenbyte -= 0x80;
        if (lenbyte > inputlen - pos) {
            return 0;
        }
        while (lenbyte > 0 && input[pos] == 0) {
            pos++;
            lenbyte--;
        }
        static_assert(sizeof(size_t) >= 4, "size_t too small");
        if (lenbyte >= 4) {
            return 0;
        }
        slen = 0;
        while (lenbyte > 0) {
            slen = (slen << 8) + input[pos];
            pos++;
            lenbyte--;
        }
    } else {
        slen = lenbyte;
    }
    if (slen > inputlen - pos) {
        return 0;
    }
    spos = pos;
    while (rlen > 0 && input[rpos] == 0) {
        rlen--;
        rpos++;
    }
    if (rlen > 32) {
        overflow = 1;
    } else {
        memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
    }
    while (slen > 0 && input[spos] == 0) {
        slen--;
        spos++;
    }
    if (slen > 32) {
        overflow = 1;
    } else {
        memcpy(tmpsig + 64 - slen, input + spos, slen);
    }
    if (!overflow) {
        overflow = !secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
    }
    if (overflow) {
        memset(tmpsig, 0, 64);
        secp256k1_ecdsa_signature_parse_compact(ctx, sig, tmpsig);
    }
    return 1;
}
static int ecdsa_signature_parse_der_lax ( const secp256k1_context * ctx , secp256k1_ecdsa_signature * sig , const unsigned char * input , size_t inputlen ) { size_t rpos , rlen , spos , slen ; size_t pos = 0 ; size_t lenbyte ; unsigned char tmpsig [ 64 ] = { 0 } ; int overflow = 0 ; secp256k1_ecdsa_signature_parse_compact ( ctx , sig , tmpsig ) ; if ( pos == inputlen || input [ pos ] != 0x30 ) { return 0 ; } pos ++ ; if ( pos == inputlen ) { return 0 ; } lenbyte = input [ pos ++ ] ; if ( lenbyte & 0x80 ) { lenbyte -= 0x80 ; if ( lenbyte > inputlen - pos ) { return 0 ; } pos += lenbyte ; } if ( pos == inputlen || input [ pos ] != 0x02 ) { return 0 ; } pos ++ ; if ( pos == inputlen ) { return 0 ; } lenbyte = input [ pos ++ ] ; if ( lenbyte & 0x80 ) { lenbyte -= 0x80 ; if ( lenbyte > inputlen - pos ) { return 0 ; } while ( lenbyte > 0 && input [ pos ] == 0 ) { pos ++ ; lenbyte -- ; } static_assert ( sizeof ( size_t ) >= 4 , " " ) ; if ( lenbyte >= 4 ) { return 0 ; } rlen = 0 ; while ( lenbyte > 0 ) { rlen = ( rlen << 8 ) + input [ pos ] ; pos ++ ; lenbyte -- ; } } else { rlen = lenbyte ; } if ( rlen > inputlen - pos ) { return 0 ; } rpos = pos ; pos += rlen ; if ( pos == inputlen || input [ pos ] != 0x02 ) { return 0 ; } pos ++ ; if ( pos == inputlen ) { return 0 ; } lenbyte = input [ pos ++ ] ; if ( lenbyte & 0x80 ) { lenbyte -= 0x80 ; if ( lenbyte > inputlen - pos ) { return 0 ; } while ( lenbyte > 0 && input [ pos ] == 0 ) { pos ++ ; lenbyte -- ; } static_assert ( sizeof ( size_t ) >= 4 , " " ) ; if ( lenbyte >= 4 ) { return 0 ; } slen = 0 ; while ( lenbyte > 0 ) { slen = ( slen << 8 ) + input [ pos ] ; pos ++ ; lenbyte -- ; } } else { slen = lenbyte ; } if ( slen > inputlen - pos ) { return 0 ; } spos = pos ; while ( rlen > 0 && input [ rpos ] == 0 ) { rlen -- ; rpos ++ ; } if ( rlen > 32 ) { overflow = 1 ; } else { memcpy ( tmpsig + 32 - rlen , input + rpos , rlen ) ; } while ( slen > 0 && input [ spos ] == 0 ) { slen -- ; spos ++ ; } if ( slen > 32 ) { overflow = 1 ; } else { memcpy ( tmpsig + 64 - slen , input + spos , slen ) ; } if ( ! overflow ) { overflow = ! secp256k1_ecdsa_signature_parse_compact ( ctx , sig , tmpsig ) ; } if ( overflow ) { memset ( tmpsig , 0 , 64 ) ; secp256k1_ecdsa_signature_parse_compact ( ctx , sig , tmpsig ) ; } return 1 ; }
This function is taken from the libsecp256k1 distribution and implements
  DER parsing for ECDSA signatures, while supporting an arbitrary subset of
  format violations.
This function is taken from the libsecp256k1 distribution and implements DER parsing for ECDSA signatures while supporting an arbitrary subset of format violations .
/* Hack to initialize sig with a correctly-parsed but invalid signature. */ /* Sequence tag byte */ /* Sequence length bytes */ /* Integer tag byte for R */ /* Integer length for R */ /* Integer tag byte for S */ /* Integer length for S */ /* Ignore leading zeroes in R */ /* Copy R value */ /* Ignore leading zeroes in S */ /* Copy S value */ /* Overwrite the result again with a correctly-parsed but invalid
           signature if parsing failed. */