void DIV32(reg_t r1, reg_t r2, reg_t r3, reg_t scratch) { MOV32(scratch, r2); MOVIM32(r1, 0); EQ32(scratch+4, r3, R_ZERO); if (REG32(scratch+4)) { goto _end; } GTE32(scratch+4, scratch, r3, scratch+8); GT32(scratch+8, scratch, R_ZERO); LAND32(scratch+12, scratch+4, scratch+8); while (REG32(scratch+12)) { INC32(r1); SUB32(scratch, scratch, r3); GTE32(scratch+4, scratch, r3, scratch+8); GT32(scratch+8, scratch, R_ZERO); LAND32(scratch+12, scratch+4, scratch+8); } _end: return; }
static void ctr32_encrypt_blocks_inplace(const unsigned char *in, unsigned char *out, size_t blocks, const AES_KEY *key, const unsigned char ivec[16]) { unsigned i; uint8_t ctr[16]; uint8_t tmp[16]; memcpy(ctr, ivec, 16); for (i=0;i<blocks;i++) { aes_v8_encrypt(ctr, tmp, key); memxor3(out, tmp, in, 16); out += 16; in += 16; INC32(ctr); } }
static void ctr32_encrypt_blocks(const unsigned char *in, unsigned char *out, size_t blocks, const AES_KEY *key, const unsigned char ivec[16]) { unsigned i; uint8_t ctr[16]; if (in == out) return ctr32_encrypt_blocks_inplace(in, out, blocks, key, ivec); memcpy(ctr, ivec, 16); for (i=0;i<blocks;i++) { aes_v8_encrypt(ctr, out, key); memxor(out, in, 16); out += 16; in += 16; INC32(ctr); } }
/* SSL 2.0 imlementation for SSL_read/SSL_peek - * This routine will return 0 to len bytes, decrypted etc if required. */ static int ssl2_read_internal(SSL *s, void *buf, int len, int peek) { int n; unsigned char mac[MAX_MAC_SIZE]; unsigned char *p; int i; int mac_size; ssl2_read_again: if (SSL_in_init(s) && !s->in_handshake) { n=s->handshake_func(s); if (n < 0) return(n); if (n == 0) { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_SSL_HANDSHAKE_FAILURE); return(-1); } } clear_sys_error(); s->rwstate=SSL_NOTHING; if (len <= 0) return(len); if (s->s2->ract_data_length != 0) /* read from buffer */ { if (len > s->s2->ract_data_length) n=s->s2->ract_data_length; else n=len; memcpy(buf,s->s2->ract_data,(unsigned int)n); if (!peek) { s->s2->ract_data_length-=n; s->s2->ract_data+=n; if (s->s2->ract_data_length == 0) s->rstate=SSL_ST_READ_HEADER; } return(n); } /* s->s2->ract_data_length == 0 * * Fill the buffer, then goto ssl2_read_again. */ if (s->rstate == SSL_ST_READ_HEADER) { if (s->first_packet) { n=read_n(s,5,SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2,0); if (n <= 0) return(n); /* error or non-blocking */ s->first_packet=0; p=s->packet; if (!((p[0] & 0x80) && ( (p[2] == SSL2_MT_CLIENT_HELLO) || (p[2] == SSL2_MT_SERVER_HELLO)))) { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_NON_SSLV2_INITIAL_PACKET); return(-1); } } else { n=read_n(s,2,SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2,0); if (n <= 0) return(n); /* error or non-blocking */ } /* part read stuff */ s->rstate=SSL_ST_READ_BODY; p=s->packet; /* Do header */ /*s->s2->padding=0;*/ s->s2->escape=0; s->s2->rlength=(((unsigned int)p[0])<<8)|((unsigned int)p[1]); if ((p[0] & TWO_BYTE_BIT)) /* Two byte header? */ { s->s2->three_byte_header=0; s->s2->rlength&=TWO_BYTE_MASK; } else { s->s2->three_byte_header=1; s->s2->rlength&=THREE_BYTE_MASK; /* security >s2->escape */ s->s2->escape=((p[0] & SEC_ESC_BIT))?1:0; } } if (s->rstate == SSL_ST_READ_BODY) { n=s->s2->rlength+2+s->s2->three_byte_header; if (n > (int)s->packet_length) { n-=s->packet_length; i=read_n(s,(unsigned int)n,(unsigned int)n,1); if (i <= 0) return(i); /* ERROR */ } p= &(s->packet[2]); s->rstate=SSL_ST_READ_HEADER; if (s->s2->three_byte_header) s->s2->padding= *(p++); else s->s2->padding=0; /* Data portion */ if (s->s2->clear_text) { mac_size = 0; s->s2->mac_data=p; s->s2->ract_data=p; if (s->s2->padding) { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING); return(-1); } } else { mac_size=EVP_MD_CTX_size(s->read_hash); if (mac_size < 0) return -1; OPENSSL_assert(mac_size <= MAX_MAC_SIZE); s->s2->mac_data=p; s->s2->ract_data= &p[mac_size]; if (s->s2->padding + mac_size > s->s2->rlength) { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_ILLEGAL_PADDING); return(-1); } } s->s2->ract_data_length=s->s2->rlength; /* added a check for length > max_size in case * encryption was not turned on yet due to an error */ if ((!s->s2->clear_text) && (s->s2->rlength >= (unsigned int)mac_size)) { ssl2_enc(s,0); s->s2->ract_data_length-=mac_size; ssl2_mac(s,mac,0); s->s2->ract_data_length-=s->s2->padding; if ( (CRYPTO_memcmp(mac,s->s2->mac_data,mac_size) != 0) || (s->s2->rlength%EVP_CIPHER_CTX_block_size(s->enc_read_ctx) != 0)) { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_BAD_MAC_DECODE); return(-1); } } INC32(s->s2->read_sequence); /* expect next number */ /* s->s2->ract_data is now available for processing */ /* Possibly the packet that we just read had 0 actual data bytes. * (SSLeay/OpenSSL itself never sends such packets; see ssl2_write.) * In this case, returning 0 would be interpreted by the caller * as indicating EOF, so it's not a good idea. Instead, we just * continue reading; thus ssl2_read_internal may have to process * multiple packets before it can return. * * [Note that using select() for blocking sockets *never* guarantees * that the next SSL_read will not block -- the available * data may contain incomplete packets, and except for SSL 2, * renegotiation can confuse things even more.] */ goto ssl2_read_again; /* This should really be * "return ssl2_read(s,buf,len)", * but that would allow for * denial-of-service attacks if a * C compiler is used that does not * recognize end-recursion. */ } else { SSLerr(SSL_F_SSL2_READ_INTERNAL,SSL_R_BAD_STATE); return(-1); } }
int main(void) { int ret = 0; INIT_MACHINE(); reg_t numCount = 1; reg_t upCount = 2; reg_t lowCount = 3; reg_t specialCount = 4; reg_t otherCount = 5; reg_t spaceCount = 6; MOVIM8(numCount, 0); MOVIM8(spaceCount, 0); MOVIM8(upCount, 0); MOVIM8(lowCount, 0); MOVIM8(specialCount, 0); MOVIM8(otherCount, 0); reg_t numString = 7; reg_t upString = 9; reg_t lowString = 11; reg_t spaceString = 13; reg_t specialString = 15; reg_t otherString = 17; reg_t newlineString = 19; MOVIM16(numString, ADDR(0)); MOVIM16(spaceString, ADDR(16)); MOVIM16(upString, ADDR(32)); MOVIM16(lowString, ADDR(48)); MOVIM16(specialString, ADDR(64)); MOVIM16(otherString, ADDR(80)); MOVIM16(newlineString, ADDR(96)); reg_t i = 21; // 123456789012 insertString(numString, "numbers = ", i); insertString(spaceString, "spaces = ", i); insertString(upString, "uppers = ", i); insertString(lowString, "lowers = ", i); insertString(specialString, "special = ", i); insertString(otherString, "other = ", i); //endl MOVIM8(REG16(newlineString), '\n'); MOVIM32(REG16(newlineString) + 1, 0); ret = getChar(i); while (ret != (-1)) { if (isUpLetter(i, i+1)) { INC8(upCount); } else if (isLowLetter(i, i+1)) { INC8(lowCount); } else if (isNumber(i, i+1)) { INC8(numCount); } else if (isSpace(i, i+1)) { #ifdef PATCHED INC8(spaceCount); #else INC32(spaceCount); #endif } else if (isSpecial(i, i+1)) { INC8(specialCount); } else { INC8(otherCount); } printChar(i); ret = getChar(i); } printString(numString, i, i+4); printReg8(numCount, i); printString(newlineString, i, i+4); printString(upString, i, i+4); printReg8(upCount, i); printString(newlineString, i, i+4); printString(lowString, i, i+4); printReg8(lowCount, i); printString(newlineString, i, i+4); printString(spaceString, i, i+4); printReg8(spaceCount, i); printString(newlineString, i, i+4); printString(specialString, i, i+4); printReg8(specialCount, i); printString(newlineString, i, i+4); printString(otherString, i, i+4); printReg8(otherCount, i); printString(newlineString, i, i+4); return (0); }
unsigned int fattr_size(const struct nfs_fattr_set *attr) { uint64_t bitmap = attr->bitmap; unsigned int total = 0; if (bitmap & (1ULL << FATTR4_SUPPORTED_ATTRS)) { INCMAP(fattr_supported_mask); } if (bitmap & (1ULL << FATTR4_TYPE)) { INC32(attr->type); } if (bitmap & (1ULL << FATTR4_FH_EXPIRE_TYPE)) { INC32(attr->fh_expire_type); } if (bitmap & (1ULL << FATTR4_CHANGE)) { INC64(attr->change); } if (bitmap & (1ULL << FATTR4_SIZE)) { INC64(attr->size); } if (bitmap & (1ULL << FATTR4_LINK_SUPPORT)) { INC32(attr->link_support ? 1 : 0); } if (bitmap & (1ULL << FATTR4_SYMLINK_SUPPORT)) { INC32(attr->symlink_support ? 1 : 0); } if (bitmap & (1ULL << FATTR4_NAMED_ATTR)) { INC32(attr->named_attr ? 1 : 0); } if (bitmap & (1ULL << FATTR4_FSID)) { INC64(attr->fsid.major); INC64(attr->fsid.minor); } if (bitmap & (1ULL << FATTR4_UNIQUE_HANDLES)) { INC32(attr->unique_handles ? 1 : 0); } if (bitmap & (1ULL << FATTR4_LEASE_TIME)) { INC32(attr->lease_time); } if (bitmap & (1ULL << FATTR4_RDATTR_ERROR)) { INC32(attr->rdattr_error); } #if 0 /* FIXME */ if (bitmap & (1ULL << FATTR4_ACL)) { encode_acl(&attr->acl, writes, wr); } #endif if (bitmap & (1ULL << FATTR4_ACLSUPPORT)) { INC32(attr->aclsupport); } if (bitmap & (1ULL << FATTR4_ARCHIVE)) { INC32(attr->archive ? 1 : 0); } if (bitmap & (1ULL << FATTR4_CANSETTIME)) { INC32(attr->cansettime ? 1 : 0); } if (bitmap & (1ULL << FATTR4_CASE_INSENSITIVE)) { INC32(attr->case_insensitive ? 1 : 0); } if (bitmap & (1ULL << FATTR4_CASE_PRESERVING)) { INC32(attr->case_preserving ? 1 : 0); } if (bitmap & (1ULL << FATTR4_CHOWN_RESTRICTED)) { INC32(attr->chown_restricted ? 1 : 0); } if (bitmap & (1ULL << FATTR4_FILEHANDLE)) { INC32(sizeof(struct nfs_fh)); INC64(attr->filehandle); } if (bitmap & (1ULL << FATTR4_FILEID)) { INC64(attr->fileid); } if (bitmap & (1ULL << FATTR4_FILES_AVAIL)) { INC64(attr->files_avail); } if (bitmap & (1ULL << FATTR4_FILES_FREE)) { INC64(attr->files_free); } if (bitmap & (1ULL << FATTR4_FILES_TOTAL)) { INC64(attr->files_total); } if (bitmap & (1ULL << FATTR4_FS_LOCATIONS)) { INC32(1); INCSTR("/"); /* fs_root */ INC32(1); /* location len */ INC32(1); /* location[0].server len */ INCSTR(my_hostname); /* location[0].server[0] */ INC32(1); INCSTR("/"); /* location[0].rootpath */ } if (bitmap & (1ULL << FATTR4_HIDDEN)) { INC32(attr->hidden ? 1 : 0); } if (bitmap & (1ULL << FATTR4_HOMOGENEOUS)) { INC32(attr->homogeneous ? 1 : 0); } if (bitmap & (1ULL << FATTR4_MAXFILESIZE)) { INC64(attr->maxfilesize); } if (bitmap & (1ULL << FATTR4_MAXLINK)) { INC32(attr->maxlink); } if (bitmap & (1ULL << FATTR4_MAXNAME)) { INC32(attr->maxname); } if (bitmap & (1ULL << FATTR4_MAXREAD)) { INC64(attr->maxread); } if (bitmap & (1ULL << FATTR4_MAXWRITE)) { INC64(attr->maxwrite); } if ((bitmap & (1ULL << FATTR4_MIMETYPE)) && (attr->mimetype.len)) { INCBUF(&attr->mimetype); } if (bitmap & (1ULL << FATTR4_MODE)) { INC32(attr->mode); } if (bitmap & (1ULL << FATTR4_NO_TRUNC)) { INC32(attr->no_trunc ? 1 : 0); } if (bitmap & (1ULL << FATTR4_NUMLINKS)) { INC32(attr->numlinks); } if ((bitmap & (1ULL << FATTR4_OWNER)) && (attr->owner.len)) { INCBUF(&attr->owner); } if ((bitmap & (1ULL << FATTR4_OWNER_GROUP)) && (attr->owner_group.len)){ INCBUF(&attr->owner_group); } if (bitmap & (1ULL << FATTR4_QUOTA_AVAIL_HARD)) { INC64(attr->quota_avail_hard); } if (bitmap & (1ULL << FATTR4_QUOTA_AVAIL_SOFT)) { INC64(attr->quota_avail_soft); } if (bitmap & (1ULL << FATTR4_QUOTA_USED)) { INC64(attr->quota_used); } if (bitmap & (1ULL << FATTR4_RAWDEV)) { /* FIXME: correct order of these two dwords? */ INC32(attr->rawdev.specdata1); INC32(attr->rawdev.specdata2); } if (bitmap & (1ULL << FATTR4_SPACE_AVAIL)) { INC64(attr->space_avail); } if (bitmap & (1ULL << FATTR4_SPACE_FREE)) { INC64(attr->space_free); } if (bitmap & (1ULL << FATTR4_SPACE_TOTAL)) { INC64(attr->space_total); } if (bitmap & (1ULL << FATTR4_SPACE_USED)) { INC64(attr->space_used); } if (bitmap & (1ULL << FATTR4_SYSTEM)) { INC32(attr->system ? 1 : 0); } if (bitmap & (1ULL << FATTR4_TIME_ACCESS)) { INC64(attr->time_access.seconds); INC32(attr->time_access.nseconds); } if (bitmap & (1ULL << FATTR4_TIME_BACKUP)) { INC64(attr->time_backup.seconds); INC32(attr->time_backup.nseconds); } if (bitmap & (1ULL << FATTR4_TIME_CREATE)) { INC64(attr->time_create.seconds); INC32(attr->time_create.nseconds); } if (bitmap & (1ULL << FATTR4_TIME_DELTA)) { INC64(attr->time_delta.seconds); INC32(attr->time_delta.nseconds); } if (bitmap & (1ULL << FATTR4_TIME_METADATA)) { INC64(attr->time_metadata.seconds); INC32(attr->time_metadata.nseconds); } if (bitmap & (1ULL << FATTR4_TIME_MODIFY)) { INC64(attr->time_modify.seconds); INC32(attr->time_modify.nseconds); } if (bitmap & (1ULL << FATTR4_MOUNTED_ON_FILEID)) { INC64(attr->mounted_on_fileid); } return total; }