/* ==================== Find ==================== */ U32 EChunk::Find(const CHAR* name, const Vector2& st) { GUARD(EChunk::Find); CHECK(name); // searche the layer table for(U32 i = 0; i < mLayers.size(); i++) { if(mLayers[i].name == name && mLayers[i].st == st) return i; } // create the new layer Layer layer; layer.name = name; layer.st = st; layer.alpha.resize(U2P(ALPHA_STRIDE)*U2P(ALPHA_STRIDE), 0); layer.total = 0; // create the new primitive layer.primitive = GNEW(Primitive); CHECK(layer.primitive); layer.primitive->SetType(Primitive::PT_TRIANGLES); layer.primitive->SetVertexBuffer(mVBPtr.Ptr()); layer.primitive->SetIndexBuffer(mIBPtr.Ptr()); layer.primitive->SetConstant("gWVP",GNEW(Constant(Matrix()))); // get the color texture KeyPtr texture_key_ptr = Key::Find(name); if(texture_key_ptr == NULL) { const Image* image = Image::Load(GLoad(name)); CHECK(image); BaseTexture* base_texture = GNEW(Texture); CHECK(base_texture); base_texture->Load(image); texture_key_ptr = GNEW(Key(name, base_texture)); CHECK(texture_key_ptr); } mKeys.push_back(texture_key_ptr); layer.primitive->SetConstant("gColorTex",GNEW(Constant((BaseTexture*)texture_key_ptr->Ptr()))); // set the scale st layer.primitive->SetConstant("gScaleST",GNEW(Constant(Vector4(st[0],st[1],0,0)))); // set the alpha U32 width = U2P(ALPHA_STRIDE); U32 height = U2P(ALPHA_STRIDE); Image* image = GNEW(Image); CHECK(image); image->Width(width); image->Height(height); image->PixelFormat(PF_ALPHA); image->DataType(DT_UNSIGNED_BYTE); image->MipmapCount(1); image->Mipmap(0,&layer.alpha[0],width*height*sizeof(U8)); BaseTexture *alpha_texture = GNEW(Texture); CHECK(alpha_texture); alpha_texture->Load(image); layer.primitive->SetConstant("gAlphaTex",GNEW(Constant(alpha_texture))); layer.texture = alpha_texture; // load the shader layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "layer"); // add the layer to the table mLayers.push_back(layer); return mLayers.size() - 1; UNGUARD; }
int Epoll_Watcher::end_loop(void) { GUARD(Mutex, mon, io_lock_); GUARD(Mutex, mon1, tq_lock_); end_flag_ = true; return 0; }
int s2n_connection_set_fd(struct s2n_connection *conn, int fd) { GUARD(s2n_connection_set_read_fd(conn, fd)); GUARD(s2n_connection_set_write_fd(conn, fd)); return 0; }
static int s2n_set_cipher_and_cert_as_server(struct s2n_connection *conn, uint8_t * wire, uint32_t count, uint32_t cipher_suite_len) { uint8_t renegotiation_info_scsv[S2N_TLS_CIPHER_SUITE_LEN] = { TLS_EMPTY_RENEGOTIATION_INFO_SCSV }; struct s2n_cipher_suite *higher_vers_match = NULL; struct s2n_cert_chain_and_key *higher_vers_cert = NULL; /* RFC 7507 - If client is attempting to negotiate a TLS Version that is lower than the highest supported server * version, and the client cipher list contains TLS_FALLBACK_SCSV, then the server must abort the connection since * TLS_FALLBACK_SCSV should only be present when the client previously failed to negotiate a higher TLS version. */ if (conn->client_protocol_version < s2n_highest_protocol_version) { uint8_t fallback_scsv[S2N_TLS_CIPHER_SUITE_LEN] = { TLS_FALLBACK_SCSV }; if (s2n_wire_ciphers_contain(fallback_scsv, wire, count, cipher_suite_len)) { conn->closed = 1; S2N_ERROR(S2N_ERR_FALLBACK_DETECTED); } } /* RFC5746 Section 3.6: A server must check if TLS_EMPTY_RENEGOTIATION_INFO_SCSV is included */ if (s2n_wire_ciphers_contain(renegotiation_info_scsv, wire, count, cipher_suite_len)) { conn->secure_renegotiation = 1; } const struct s2n_cipher_preferences *cipher_preferences; GUARD(s2n_connection_get_cipher_preferences(conn, &cipher_preferences)); /* s2n supports only server order */ for (int i = 0; i < cipher_preferences->count; i++) { conn->handshake_params.our_chain_and_key = NULL; const uint8_t *ours = cipher_preferences->suites[i]->iana_value; if (s2n_wire_ciphers_contain(ours, wire, count, cipher_suite_len)) { /* We have a match */ struct s2n_cipher_suite *match = s2n_cipher_suite_from_wire(ours); /* If connection is for SSLv3, use SSLv3 version of suites */ if (conn->client_protocol_version == S2N_SSLv3) { match = match->sslv3_cipher_suite; } /* Skip the suite if it is not compatible with any certificates */ conn->handshake_params.our_chain_and_key = s2n_get_compatible_cert_chain_and_key(conn, match); if (!conn->handshake_params.our_chain_and_key) { continue; } /* Skip the suite if we don't have an available implementation */ if (!match->available) { continue; } if (!s2n_kex_supported(match->key_exchange_alg, conn)) { continue; } /* Don't immediately choose a cipher the client shouldn't be able to support */ if (conn->client_protocol_version < match->minimum_required_tls_version) { if (!higher_vers_match) { higher_vers_match = match; higher_vers_cert = conn->handshake_params.our_chain_and_key; } continue; } conn->secure.cipher_suite = match; return 0; } } /* Settle for a cipher with a higher required proto version, if it was set */ if (higher_vers_match) { conn->secure.cipher_suite = higher_vers_match; conn->handshake_params.our_chain_and_key = higher_vers_cert; return 0; } S2N_ERROR(S2N_ERR_CIPHER_NOT_SUPPORTED); }
static int s2n_drbg_bits(struct s2n_drbg *drbg, struct s2n_blob *out) { struct s2n_blob value = {.data = drbg->v,.size = sizeof(drbg->v) }; int block_aligned_size = out->size - (out->size % S2N_DRBG_BLOCK_SIZE); /* Per NIST SP800-90A 10.2.1.2: */ for (int i = 0; i < block_aligned_size; i += S2N_DRBG_BLOCK_SIZE) { GUARD(s2n_increment_sequence_number(&value)); GUARD(s2n_drbg_block_encrypt(drbg->ctx, drbg->v, out->data + i)); drbg->bytes_used += S2N_DRBG_BLOCK_SIZE; } if (out->size <= block_aligned_size) { return 0; } uint8_t spare_block[S2N_DRBG_BLOCK_SIZE]; GUARD(s2n_increment_sequence_number(&value)); GUARD(s2n_drbg_block_encrypt(drbg->ctx, drbg->v, spare_block)); drbg->bytes_used += S2N_DRBG_BLOCK_SIZE; memcpy_check(out->data + block_aligned_size, spare_block, out->size - block_aligned_size); return 0; } static int s2n_drbg_update(struct s2n_drbg *drbg, struct s2n_blob *provided_data) { uint8_t temp[32]; struct s2n_blob temp_blob = {.data = temp,.size = sizeof(temp) }; eq_check(provided_data->size, sizeof(temp)); GUARD(s2n_drbg_bits(drbg, &temp_blob)); /* XOR in the provided data */ for (int i = 0; i < provided_data->size; i++) { temp[i] ^= provided_data->data[i]; } /* Update the key and value */ GUARD_OSSL(EVP_EncryptInit_ex(drbg->ctx, EVP_aes_128_ecb(), NULL, temp, NULL), S2N_ERR_DRBG); memcpy_check(drbg->v, temp + S2N_DRBG_BLOCK_SIZE, S2N_DRBG_BLOCK_SIZE); return 0; } int s2n_drbg_seed(struct s2n_drbg *drbg, struct s2n_blob *ps) { uint8_t seed[32]; struct s2n_blob blob = {.data = seed,.size = sizeof(seed) }; lte_check(ps->size, sizeof(seed)); if (drbg->entropy_generator) { GUARD(drbg->entropy_generator(&blob)); } else { GUARD(s2n_get_urandom_data(&blob)); } for (int i = 0; i < ps->size; i++) { blob.data[i] ^= ps->data[i]; } GUARD(s2n_drbg_update(drbg, &blob)); drbg->bytes_used = 0; drbg->generation += 1; return 0; } int s2n_drbg_instantiate(struct s2n_drbg *drbg, struct s2n_blob *personalization_string) { struct s2n_blob value = {.data = drbg->v,.size = sizeof(drbg->v) }; uint8_t ps_prefix[32]; struct s2n_blob ps = {.data = ps_prefix,.size = sizeof(ps_prefix) }; /* Start off with zeroed data, per 10.2.1.3.1 item 4 */ GUARD(s2n_blob_zero(&value)); drbg->ctx = EVP_CIPHER_CTX_new(); S2N_ERROR_IF(!drbg->ctx, S2N_ERR_DRBG); (void)EVP_CIPHER_CTX_init(drbg->ctx); /* Start off with zeroed key, per 10.2.1.3.1 item 5 */ GUARD_OSSL(EVP_EncryptInit_ex(drbg->ctx, EVP_aes_128_ecb(), NULL, drbg->v, NULL), S2N_ERR_DRBG); /* Copy the personalization string */ GUARD(s2n_blob_zero(&ps)); memcpy_check(ps.data, personalization_string->data, MIN(ps.size, personalization_string->size)); /* Seed / update the DRBG */ GUARD(s2n_drbg_seed(drbg, &ps)); /* After initial seeding, pivot to RDRAND if available and not overridden */ if (drbg->entropy_generator == NULL && s2n_cpu_supports_rdrand()) { drbg->entropy_generator = s2n_get_rdrand_data; } return 0; } int s2n_drbg_generate(struct s2n_drbg *drbg, struct s2n_blob *blob) { uint8_t all_zeros[32] = { 0 }; struct s2n_blob zeros = {.data = all_zeros,.size = sizeof(all_zeros) }; S2N_ERROR_IF(blob->size > S2N_DRBG_GENERATE_LIMIT, S2N_ERR_DRBG_REQUEST_SIZE); /* If either the entropy generator is set, for prediction resistance, * or if we reach the definitely-need-to-reseed limit, then reseed. */ if (drbg->entropy_generator || drbg->bytes_used + blob->size + S2N_DRBG_BLOCK_SIZE >= S2N_DRBG_RESEED_LIMIT) { GUARD(s2n_drbg_seed(drbg, &zeros)); } GUARD(s2n_drbg_bits(drbg, blob)); GUARD(s2n_drbg_update(drbg, &zeros)); return 0; } int s2n_drbg_wipe(struct s2n_drbg *drbg) { struct s2n_blob state = {.data = (void *)drbg,.size = sizeof(struct s2n_drbg) }; if (drbg->ctx) { GUARD_OSSL(EVP_CIPHER_CTX_cleanup(drbg->ctx), S2N_ERR_DRBG); EVP_CIPHER_CTX_free(drbg->ctx); drbg->ctx = NULL; } GUARD(s2n_blob_zero(&state)); return 0; } int s2n_drbg_bytes_used(struct s2n_drbg *drbg) { return drbg->bytes_used; }
int s2n_server_cert_send(struct s2n_connection *conn) { GUARD(s2n_send_cert_chain(&conn->handshake.io, conn->handshake_params.our_chain_and_key->cert_chain)); return 0; }
int s2n_prf_key_expansion(struct s2n_connection *conn) { struct s2n_blob client_random = {.data = conn->secure.client_random,.size = sizeof(conn->secure.client_random) }; struct s2n_blob server_random = {.data = conn->secure.server_random,.size = sizeof(conn->secure.server_random) }; struct s2n_blob master_secret = {.data = conn->secure.master_secret,.size = sizeof(conn->secure.master_secret) }; struct s2n_blob label, out; uint8_t key_expansion_label[] = "key expansion"; uint8_t key_block[S2N_MAX_KEY_BLOCK_LEN]; label.data = key_expansion_label; label.size = sizeof(key_expansion_label) - 1; out.data = key_block; out.size = sizeof(key_block); struct s2n_stuffer key_material; GUARD(s2n_prf(conn, &master_secret, &label, &server_random, &client_random, &out)); GUARD(s2n_stuffer_init(&key_material, &out)); GUARD(s2n_stuffer_write(&key_material, &out)); GUARD(conn->secure.cipher_suite->cipher->init(&conn->secure.client_key)); GUARD(conn->secure.cipher_suite->cipher->init(&conn->secure.server_key)); /* What's our hmac algorithm? */ s2n_hmac_algorithm hmac_alg = conn->secure.cipher_suite->hmac_alg; if (conn->actual_protocol_version == S2N_SSLv3) { if (hmac_alg == S2N_HMAC_SHA1) { hmac_alg = S2N_HMAC_SSLv3_SHA1; } else if (hmac_alg == S2N_HMAC_MD5) { hmac_alg = S2N_HMAC_SSLv3_MD5; } else { S2N_ERROR(S2N_ERR_HMAC_INVALID_ALGORITHM); } } /* Check that we have a valid MAC and key size */ int mac_size; GUARD((mac_size = s2n_hmac_digest_size(hmac_alg))); /* Seed the client MAC */ uint8_t *client_write_mac_key = s2n_stuffer_raw_read(&key_material, mac_size); notnull_check(client_write_mac_key); GUARD(s2n_hmac_init(&conn->secure.client_record_mac, hmac_alg, client_write_mac_key, mac_size)); /* Seed the server MAC */ uint8_t *server_write_mac_key = s2n_stuffer_raw_read(&key_material, mac_size); notnull_check(server_write_mac_key); GUARD(s2n_hmac_init(&conn->secure.server_record_mac, hmac_alg, server_write_mac_key, mac_size)); /* Make the client key */ struct s2n_blob client_key; client_key.size = conn->secure.cipher_suite->cipher->key_material_size; client_key.data = s2n_stuffer_raw_read(&key_material, client_key.size); notnull_check(client_key.data); if (conn->mode == S2N_CLIENT) { GUARD(conn->secure.cipher_suite->cipher->get_encryption_key(&conn->secure.client_key, &client_key)); } else { GUARD(conn->secure.cipher_suite->cipher->get_decryption_key(&conn->secure.client_key, &client_key)); } /* Make the server key */ struct s2n_blob server_key; server_key.size = conn->secure.cipher_suite->cipher->key_material_size; server_key.data = s2n_stuffer_raw_read(&key_material, server_key.size); notnull_check(server_key.data); if (conn->mode == S2N_SERVER) { GUARD(conn->secure.cipher_suite->cipher->get_encryption_key(&conn->secure.server_key, &server_key)); } else { GUARD(conn->secure.cipher_suite->cipher->get_decryption_key(&conn->secure.server_key, &server_key)); } /* TLS >= 1.1 has no implicit IVs for non AEAD ciphers */ if (conn->actual_protocol_version > S2N_TLS10 && conn->secure.cipher_suite->cipher->type != S2N_AEAD) { return 0; } uint32_t implicit_iv_size = 0; switch(conn->secure.cipher_suite->cipher->type) { case S2N_AEAD: implicit_iv_size = conn->secure.cipher_suite->cipher->io.aead.fixed_iv_size; break; case S2N_CBC: implicit_iv_size = conn->secure.cipher_suite->cipher->io.cbc.block_size; break; /* No-op for stream ciphers */ default: break; } struct s2n_blob client_implicit_iv = { .data = conn->secure.client_implicit_iv, .size = implicit_iv_size }; struct s2n_blob server_implicit_iv = { .data = conn->secure.server_implicit_iv, .size = implicit_iv_size }; GUARD(s2n_stuffer_read(&key_material, &client_implicit_iv)); GUARD(s2n_stuffer_read(&key_material, &server_implicit_iv)); return 0; }
int s2n_connection_wipe(struct s2n_connection *conn) { /* First make a copy of everything we'd like to save, which isn't very * much. */ int mode = conn->mode; struct s2n_config *config = conn->config; struct s2n_stuffer alert_in; struct s2n_stuffer reader_alert_out; struct s2n_stuffer writer_alert_out; struct s2n_stuffer handshake_io; struct s2n_stuffer header_in; struct s2n_stuffer in; struct s2n_stuffer out; /* Session keys will be wiped. Preserve structs to avoid reallocation */ struct s2n_session_key initial_client_key; struct s2n_session_key initial_server_key; struct s2n_session_key secure_client_key; struct s2n_session_key secure_server_key; /* Wipe all of the sensitive stuff */ GUARD(s2n_connection_wipe_keys(conn)); GUARD(s2n_stuffer_wipe(&conn->alert_in)); GUARD(s2n_stuffer_wipe(&conn->reader_alert_out)); GUARD(s2n_stuffer_wipe(&conn->writer_alert_out)); GUARD(s2n_stuffer_wipe(&conn->handshake.io)); GUARD(s2n_stuffer_wipe(&conn->header_in)); GUARD(s2n_stuffer_wipe(&conn->in)); GUARD(s2n_stuffer_wipe(&conn->out)); /* Restore the socket option values */ GUARD(s2n_socket_read_restore(conn)); GUARD(s2n_socket_write_restore(conn)); GUARD(s2n_free(&conn->status_response)); /* Allocate or resize to their original sizes */ GUARD(s2n_stuffer_resize(&conn->in, S2N_LARGE_FRAGMENT_LENGTH)); /* Allocate memory for handling handshakes */ GUARD(s2n_stuffer_resize(&conn->handshake.io, S2N_LARGE_RECORD_LENGTH)); /* Clone the stuffers */ /* ignore gcc 4.7 address warnings because dest is allocated on the stack */ /* pragma gcc diagnostic was added in gcc 4.6 */ #if defined(__GNUC__) && GCC_VERSION >= 40600 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Waddress" #endif memcpy_check(&alert_in, &conn->alert_in, sizeof(struct s2n_stuffer)); memcpy_check(&reader_alert_out, &conn->reader_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&writer_alert_out, &conn->writer_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&handshake_io, &conn->handshake.io, sizeof(struct s2n_stuffer)); memcpy_check(&header_in, &conn->header_in, sizeof(struct s2n_stuffer)); memcpy_check(&in, &conn->in, sizeof(struct s2n_stuffer)); memcpy_check(&out, &conn->out, sizeof(struct s2n_stuffer)); memcpy_check(&initial_client_key, &conn->initial.client_key, sizeof(struct s2n_session_key)); memcpy_check(&initial_server_key, &conn->initial.server_key, sizeof(struct s2n_session_key)); memcpy_check(&secure_client_key, &conn->secure.client_key, sizeof(struct s2n_session_key)); memcpy_check(&secure_server_key, &conn->secure.server_key, sizeof(struct s2n_session_key)); #if defined(__GNUC__) && GCC_VERSION >= 40600 #pragma GCC diagnostic pop #endif /* Zero the whole connection structure */ memset_check(conn, 0, sizeof(struct s2n_connection)); conn->readfd = -1; conn->writefd = -1; conn->mode = mode; conn->config = config; conn->close_notify_queued = 0; conn->current_user_data_consumed = 0; conn->initial.cipher_suite = &s2n_null_cipher_suite; conn->secure.cipher_suite = &s2n_null_cipher_suite; conn->server = &conn->initial; conn->client = &conn->initial; conn->max_fragment_length = S2N_SMALL_FRAGMENT_LENGTH; conn->handshake.handshake_type = INITIAL; conn->handshake.message_number = 0; GUARD(s2n_hash_init(&conn->handshake.md5, S2N_HASH_MD5)); GUARD(s2n_hash_init(&conn->handshake.sha1, S2N_HASH_SHA1)); GUARD(s2n_hash_init(&conn->handshake.sha256, S2N_HASH_SHA256)); GUARD(s2n_hash_init(&conn->handshake.sha384, S2N_HASH_SHA384)); GUARD(s2n_hmac_init(&conn->client->client_record_mac, S2N_HMAC_NONE, NULL, 0)); GUARD(s2n_hmac_init(&conn->server->server_record_mac, S2N_HMAC_NONE, NULL, 0)); memcpy_check(&conn->alert_in, &alert_in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->reader_alert_out, &reader_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&conn->writer_alert_out, &writer_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&conn->handshake.io, &handshake_io, sizeof(struct s2n_stuffer)); memcpy_check(&conn->header_in, &header_in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->in, &in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->out, &out, sizeof(struct s2n_stuffer)); memcpy_check(&conn->initial.client_key, &initial_client_key, sizeof(struct s2n_session_key)); memcpy_check(&conn->initial.server_key, &initial_server_key, sizeof(struct s2n_session_key)); memcpy_check(&conn->secure.client_key, &secure_client_key, sizeof(struct s2n_session_key)); memcpy_check(&conn->secure.server_key, &secure_server_key, sizeof(struct s2n_session_key)); if (conn->mode == S2N_SERVER) { conn->server_protocol_version = s2n_highest_protocol_version; conn->client_protocol_version = s2n_unknown_protocol_version; } else { conn->server_protocol_version = s2n_unknown_protocol_version; conn->client_protocol_version = s2n_highest_protocol_version; } conn->actual_protocol_version = s2n_unknown_protocol_version; return 0; }
UniformBufferMetaInfo::UniformBufferMetaInfo( GLint numMaxArrayElements, String bufferName, String arrayName, std::vector<String> memberStrings, Shader* queryShader) : mNumArrayElements(numMaxArrayElements), //mArrayName(arrayName), mMemberStrings(memberStrings), mRequiredBufferSize(0), mNumMemberElements(memberStrings.size() == 0 ? 1 : memberStrings.size() ), mBufferOffsets(0) { LOG<<DEBUG_LOG_LEVEL<<bufferName<<"\n"; GLuint shaderGLProgramHandle = queryShader->getGLProgramHandle(); GLuint uniBlockIndex = GUARD( glGetUniformBlockIndex(shaderGLProgramHandle, bufferName.c_str()) ); //query needed buffer size GUARD( glGetActiveUniformBlockiv( shaderGLProgramHandle, uniBlockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, & mRequiredBufferSize ) ); //-------------------------------------------------------------------------------- mBufferOffsets = new GLint*[mNumArrayElements]; // const String memberStrings[] = // { // "position","diffuseColor","specularColor","direction", // "innerSpotCutOff_Radians","outerSpotCutOff_Radians","spotExponent","shadowMapLayer" // }; const char** indexQuery_C_StringArray= new const char*[mNumMemberElements]; String* indexQueryStringArray= new String[mNumMemberElements]; GLuint* currentUniformIndices= new GLuint[mNumMemberElements]; for(int arrayElementRunner=0; arrayElementRunner< mNumArrayElements; arrayElementRunner++) { String baseString = arrayName + String("[") + HelperFunctions::toString(arrayElementRunner) + String("]") ; mBufferOffsets[arrayElementRunner]= new GLint[mNumMemberElements]; if(memberStrings.size() != 0) { //we have a structure as array elements; construct the GL referencation strings: for(int memberRunner=0; memberRunner< mNumMemberElements; memberRunner++) { indexQueryStringArray[memberRunner]= String(baseString+ String(".") + memberStrings[memberRunner]); indexQuery_C_StringArray[memberRunner]= indexQueryStringArray[memberRunner].c_str(); } } else { //the array element constist of a single built-in type, i.e. the GL referencation strings //are a single string, beeing the base string: indexQuery_C_StringArray[0]= baseString.c_str(); } //first, get indices of current lightsource members: GUARD( glGetUniformIndices( shaderGLProgramHandle, mNumMemberElements, indexQuery_C_StringArray, currentUniformIndices ) ); //second, get offset in buffer for those members, indentified by the queried indices: GUARD( glGetActiveUniformsiv( shaderGLProgramHandle, mNumMemberElements, currentUniformIndices, GL_UNIFORM_OFFSET, mBufferOffsets[arrayElementRunner] ) ); // for(int memberRunner=0; memberRunner< mNumMemberElements; memberRunner++) // { // LOG<<DEBUG_LOG_LEVEL << String(indexQuery_C_StringArray[memberRunner])<<" ;\n"; // LOG<<DEBUG_LOG_LEVEL <<"uniform index: "<< currentUniformIndices[memberRunner] <<" ;\n"; // LOG<<DEBUG_LOG_LEVEL <<"uniform offset: "<< mBufferOffsets[arrayElementRunner][memberRunner] <<" ;\n"; // assert( "member should be active in shader, otherwise uniform buffer filling would turn out even more complicated :@" // && ( currentUniformIndices[memberRunner] != GL_INVALID_INDEX) ); // } } //endfor delete[] indexQuery_C_StringArray; delete[] indexQueryStringArray; delete[] currentUniformIndices; }
static int s2n_prf(struct s2n_connection *conn, struct s2n_blob *secret, struct s2n_blob *label, struct s2n_blob *seed_a, struct s2n_blob *seed_b, struct s2n_blob *out) { if (conn->actual_protocol_version == S2N_SSLv3) { return s2n_sslv3_prf(&conn->prf_space, secret, seed_a, seed_b, out); } /* We zero the out blob because p_hash works by XOR'ing with the existing * buffer. This is a little convuloted but means we can avoid dynamic memory * allocation. When we call p_hash once (in the TLS1.2 case) it will produce * the right values. When we call it twice in the regular case, the two * outputs will be XORd just ass the TLS 1.0 and 1.1 RFCs require. */ GUARD(s2n_blob_zero(out)); if (conn->actual_protocol_version == S2N_TLS12) { return s2n_p_hash(&conn->prf_space, conn->secure.cipher_suite->tls12_prf_alg, secret, label, seed_a, seed_b, out); } struct s2n_blob half_secret = {.data = secret->data,.size = (secret->size + 1) / 2 }; GUARD(s2n_p_hash(&conn->prf_space, S2N_HMAC_MD5, &half_secret, label, seed_a, seed_b, out)); half_secret.data += secret->size - half_secret.size; GUARD(s2n_p_hash(&conn->prf_space, S2N_HMAC_SHA1, &half_secret, label, seed_a, seed_b, out)); return 0; } int s2n_prf_master_secret(struct s2n_connection *conn, struct s2n_blob *premaster_secret) { struct s2n_blob client_random, server_random, master_secret; struct s2n_blob label; uint8_t master_secret_label[] = "master secret"; client_random.data = conn->secure.client_random; client_random.size = sizeof(conn->secure.client_random); server_random.data = conn->secure.server_random; server_random.size = sizeof(conn->secure.server_random); master_secret.data = conn->secure.master_secret; master_secret.size = sizeof(conn->secure.master_secret); label.data = master_secret_label; label.size = sizeof(master_secret_label) - 1; return s2n_prf(conn, premaster_secret, &label, &client_random, &server_random, &master_secret); } static int s2n_sslv3_finished(struct s2n_connection *conn, uint8_t prefix[4], struct s2n_hash_state *md5, struct s2n_hash_state *sha1, uint8_t *out) { uint8_t xorpad1[48] = { 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36 }; uint8_t xorpad2[48] = { 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c }; uint8_t *md5_digest = out; uint8_t *sha_digest = out + MD5_DIGEST_LENGTH; lte_check(MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH, sizeof(conn->handshake.client_finished)); GUARD(s2n_hash_update(md5, prefix, 4)); GUARD(s2n_hash_update(md5, conn->secure.master_secret, sizeof(conn->secure.master_secret))); GUARD(s2n_hash_update(md5, xorpad1, 48)); GUARD(s2n_hash_digest(md5, md5_digest, MD5_DIGEST_LENGTH)); GUARD(s2n_hash_reset(md5)); GUARD(s2n_hash_update(md5, conn->secure.master_secret, sizeof(conn->secure.master_secret))); GUARD(s2n_hash_update(md5, xorpad2, 48)); GUARD(s2n_hash_update(md5, md5_digest, MD5_DIGEST_LENGTH)); GUARD(s2n_hash_digest(md5, md5_digest, MD5_DIGEST_LENGTH)); GUARD(s2n_hash_reset(md5)); GUARD(s2n_hash_update(sha1, prefix, 4)); GUARD(s2n_hash_update(sha1, conn->secure.master_secret, sizeof(conn->secure.master_secret))); GUARD(s2n_hash_update(sha1, xorpad1, 40)); GUARD(s2n_hash_digest(sha1, sha_digest, SHA_DIGEST_LENGTH)); GUARD(s2n_hash_reset(sha1)); GUARD(s2n_hash_update(sha1, conn->secure.master_secret, sizeof(conn->secure.master_secret))); GUARD(s2n_hash_update(sha1, xorpad2, 40)); GUARD(s2n_hash_update(sha1, sha_digest, SHA_DIGEST_LENGTH)); GUARD(s2n_hash_digest(sha1, sha_digest, SHA_DIGEST_LENGTH)); GUARD(s2n_hash_reset(sha1)); return 0; }
static void Test_SingleProcess() { LOG_POST("=== Single-process test ==="); const CTimeout zero_timeout = CTimeout(0,0); LOG_POST("\n--- Test 1"); // Name test {{ try { CInterProcessLock lock(""); } catch (CInterProcessLockException&) {} try { CInterProcessLock lock("relative/path"); } catch (CInterProcessLockException&) {} {{ CInterProcessLock lock("name"); assert(lock.GetName() == "name"); #if defined(NCBI_OS_UNIX) assert(lock.GetSystemName() == "/var/tmp/name"); #elif defined(NCBI_OS_MSWIN) assert(lock.GetSystemName() == "name"); #endif }} }} // Fixed names are usually more appropriate, but here we don't // want independent tests to step on each other... string lockname = CFile::GetTmpName(); CInterProcessLock lock1(lockname); CInterProcessLock lock2(lockname); CInterProcessLock lock3(lockname); LOG_POST("lock name = " << lock1.GetName()); LOG_POST("lock system name = " << lock1.GetSystemName()); LOG_POST("\n--- Test 2"); // Direct CInterProcessLock usage {{ lock1.Lock(/*infinite*/); try { lock2.Lock(zero_timeout); assert(0); } catch (CInterProcessLockException&) {} assert( !lock2.TryLock() ); lock1.Unlock(); lock2.Lock(/*infinite*/); assert( !lock3.TryLock() ); lock2.Unlock(); lock1.Lock(zero_timeout); lock1.Remove(); // everything unlocked }} LOG_POST("\n--- Test 3"); // CGuard usage {{ {{ CGuard<CInterProcessLock> GUARD(lock1); try { lock2.Lock(zero_timeout); assert(0); } catch (CInterProcessLockException&) {} }} lock2.Lock(zero_timeout); lock2.Remove(); // everything unlocked }} LOG_POST("\n--- Test 4"); // Reference count test {{ assert( lock1.TryLock() ); assert( lock1.TryLock() ); assert( !lock2.TryLock() ); assert( lock1.TryLock() ); lock1.Unlock(); lock1.Unlock(); lock1.Unlock(); try { lock1.Unlock(); assert(0); } catch (CInterProcessLockException&) {} // everything unlocked }} // We don't need lock object anymore, remove it from the system lock1.Remove(); }
int s2n_config_free_cert_chain_and_key(struct s2n_config *config) { struct s2n_blob b = { .data = (uint8_t *) config->cert_and_key_pairs, .size = sizeof(struct s2n_cert_chain_and_key) }; /* If there were cert and key pairs set, walk the chain and free the certs */ if (config->cert_and_key_pairs) { struct s2n_cert_chain *node = config->cert_and_key_pairs->head; while (node) { struct s2n_blob n = { .data = (uint8_t *)node, .size = sizeof(struct s2n_cert_chain) }; /* Free the cert */ GUARD(s2n_free(&node->cert)); /* Advance to next */ node = node->next; /* Free the node */ GUARD(s2n_free(&n)); } GUARD(s2n_rsa_private_key_free(&config->cert_and_key_pairs->private_key)); GUARD(s2n_free(&config->cert_and_key_pairs->ocsp_status)); } GUARD(s2n_free(&b)); return 0; } int s2n_config_free_dhparams(struct s2n_config *config) { struct s2n_blob b = { .data = (uint8_t *) config->dhparams, .size = sizeof(struct s2n_dh_params) }; if (config->dhparams) { GUARD(s2n_dh_params_free(config->dhparams)); } GUARD(s2n_free(&b)); return 0; } int s2n_config_free(struct s2n_config *config) { struct s2n_blob b = {.data = (uint8_t *) config,.size = sizeof(struct s2n_config) }; GUARD(s2n_config_free_cert_chain_and_key(config)); GUARD(s2n_config_free_dhparams(config)); GUARD(s2n_free(&config->application_protocols)); GUARD(s2n_free(&b)); return 0; } int s2n_config_set_cipher_preferences(struct s2n_config *config, const char *version) { for (int i = 0; selection[i].version != NULL; i++) { if (!strcasecmp(version, selection[i].version)) { config->cipher_preferences = selection[i].preferences; return 0; } } S2N_ERROR(S2N_ERR_INVALID_CIPHER_PREFERENCES); } int s2n_config_set_protocol_preferences(struct s2n_config *config, const char * const *protocols, int protocol_count) { struct s2n_stuffer protocol_stuffer; GUARD(s2n_free(&config->application_protocols)); if (protocols == NULL || protocol_count == 0) { /* NULL value indicates no prference, so nothing to do */ return 0; } GUARD(s2n_stuffer_growable_alloc(&protocol_stuffer, 256)); for (int i = 0; i < protocol_count; i++) { size_t length = strlen(protocols[i]); uint8_t protocol[255]; if (length > 255 || (s2n_stuffer_data_available(&protocol_stuffer) + length + 1) > 65535) { return S2N_ERR_APPLICATION_PROTOCOL_TOO_LONG; } memcpy_check(protocol, protocols[i], length); GUARD(s2n_stuffer_write_uint8(&protocol_stuffer, length)); GUARD(s2n_stuffer_write_bytes(&protocol_stuffer, protocol, length)); } uint32_t size = s2n_stuffer_data_available(&protocol_stuffer); /* config->application_protocols blob now owns this data */ config->application_protocols.size = size; config->application_protocols.data = s2n_stuffer_raw_read(&protocol_stuffer, size); notnull_check(config->application_protocols.data); return 0; } int s2n_config_set_status_request_type(struct s2n_config *config, s2n_status_request_type type) { config->status_request_type = type; return 0; } int s2n_config_add_cert_chain_and_key_with_status(struct s2n_config *config, char *cert_chain_pem, char *private_key_pem, const uint8_t *status, uint32_t length) { struct s2n_stuffer chain_in_stuffer, cert_out_stuffer, key_in_stuffer, key_out_stuffer; struct s2n_blob key_blob; struct s2n_blob mem; /* Allocate the memory for the chain and key struct */ GUARD(s2n_alloc(&mem, sizeof(struct s2n_cert_chain_and_key))); config->cert_and_key_pairs = (struct s2n_cert_chain_and_key *)(void *)mem.data; config->cert_and_key_pairs->ocsp_status.data = NULL; config->cert_and_key_pairs->ocsp_status.size = 0; /* Put the private key pem in a stuffer */ GUARD(s2n_stuffer_alloc_ro_from_string(&key_in_stuffer, private_key_pem)); GUARD(s2n_stuffer_growable_alloc(&key_out_stuffer, strlen(private_key_pem))); /* Convert pem to asn1 and asn1 to the private key */ GUARD(s2n_stuffer_rsa_private_key_from_pem(&key_in_stuffer, &key_out_stuffer)); GUARD(s2n_stuffer_free(&key_in_stuffer)); key_blob.size = s2n_stuffer_data_available(&key_out_stuffer); key_blob.data = s2n_stuffer_raw_read(&key_out_stuffer, key_blob.size); notnull_check(key_blob.data); GUARD(s2n_asn1der_to_rsa_private_key(&config->cert_and_key_pairs->private_key, &key_blob)); GUARD(s2n_stuffer_free(&key_out_stuffer)); /* Turn the chain into a stuffer */ GUARD(s2n_stuffer_alloc_ro_from_string(&chain_in_stuffer, cert_chain_pem)); GUARD(s2n_stuffer_growable_alloc(&cert_out_stuffer, 2048)); struct s2n_cert_chain **insert = &config->cert_and_key_pairs->head; uint32_t chain_size = 0; do { struct s2n_cert_chain *new_node; if (s2n_stuffer_certificate_from_pem(&chain_in_stuffer, &cert_out_stuffer) < 0) { if (chain_size == 0) { S2N_ERROR(S2N_ERR_NO_CERTIFICATE_IN_PEM); } break; } GUARD(s2n_alloc(&mem, sizeof(struct s2n_cert_chain))); new_node = (struct s2n_cert_chain *)(void *)mem.data; GUARD(s2n_alloc(&new_node->cert, s2n_stuffer_data_available(&cert_out_stuffer))); GUARD(s2n_stuffer_read(&cert_out_stuffer, &new_node->cert)); /* Additional 3 bytes for the length field in the protocol */ chain_size += new_node->cert.size + 3; new_node->next = NULL; *insert = new_node; insert = &new_node->next; } while (s2n_stuffer_data_available(&chain_in_stuffer)); GUARD(s2n_stuffer_free(&chain_in_stuffer)); GUARD(s2n_stuffer_free(&cert_out_stuffer)); config->cert_and_key_pairs->chain_size = chain_size; if (status && length > 0) { GUARD(s2n_alloc(&config->cert_and_key_pairs->ocsp_status, length)); memcpy_check(config->cert_and_key_pairs->ocsp_status.data, status, length); } return 0; } int s2n_config_add_cert_chain_and_key(struct s2n_config *config, char *cert_chain_pem, char *private_key_pem) { GUARD(s2n_config_add_cert_chain_and_key_with_status(config, cert_chain_pem, private_key_pem, NULL, 0)); return 0; } int s2n_config_add_dhparams(struct s2n_config *config, char *dhparams_pem) { struct s2n_stuffer dhparams_in_stuffer, dhparams_out_stuffer; struct s2n_blob dhparams_blob; struct s2n_blob mem; /* Allocate the memory for the chain and key struct */ GUARD(s2n_alloc(&mem, sizeof(struct s2n_dh_params))); config->dhparams = (struct s2n_dh_params *)(void *)mem.data; GUARD(s2n_stuffer_alloc_ro_from_string(&dhparams_in_stuffer, dhparams_pem)); GUARD(s2n_stuffer_growable_alloc(&dhparams_out_stuffer, strlen(dhparams_pem))); /* Convert pem to asn1 and asn1 to the private key */ GUARD(s2n_stuffer_dhparams_from_pem(&dhparams_in_stuffer, &dhparams_out_stuffer)); GUARD(s2n_stuffer_free(&dhparams_in_stuffer)); dhparams_blob.size = s2n_stuffer_data_available(&dhparams_out_stuffer); dhparams_blob.data = s2n_stuffer_raw_read(&dhparams_out_stuffer, dhparams_blob.size); notnull_check(dhparams_blob.data); GUARD(s2n_pkcs3_to_dh_params(config->dhparams, &dhparams_blob)); GUARD(s2n_free(&dhparams_blob)); return 0; } int s2n_config_set_nanoseconds_since_epoch_callback(struct s2n_config *config, int (*nanoseconds_since_epoch)(void *, uint64_t *), void * data) { notnull_check(nanoseconds_since_epoch); config->nanoseconds_since_epoch = nanoseconds_since_epoch; config->data_for_nanoseconds_since_epoch = data; return 0; } int s2n_config_set_cache_store_callback(struct s2n_config *config, int (*cache_store)(void *, const void *key, uint64_t key_size, const void *value, uint64_t value_size), void *data) { notnull_check(cache_store); config->cache_store = cache_store; config->cache_store_data = data; return 0; }
/* ==================== Save ==================== */ VOID EChunk::Save(GFile& file) { GUARD(EChunk::Save); // write the chunk header U32 header = MAKEFOURCC('G','C','H','K'); file.Write(&header, sizeof(U32)); // write the number of layers U32 num_layer = mLayers.size(); file.Write(&num_layer, sizeof(U32)); // write all of the layers if(mLayers.size() == 1) { Layer& layer = mLayers[0]; // write the texture U32 name_len = layer.name.size(); file.Write(&name_len, sizeof(U32)); file.Write(layer.name.c_str(), name_len*sizeof(CHAR)); file.Write(layer.st.ptr(), 2*sizeof(F32)); // write the alpha U32 width = 1; file.Write(&width, sizeof(U32)); U32 height = 1; file.Write(&height, sizeof(U32)); U8 alpha = 127; file.Write(&alpha, sizeof(U8)); } else { for(I32 k = 0; k < mLayers.size(); k++) { Layer& layer = mLayers[k]; // write the texture U32 name_len = layer.name.size(); file.Write(&name_len, sizeof(U32)); file.Write(layer.name.c_str(), name_len*sizeof(CHAR)); file.Write(layer.st.ptr(), 2*sizeof(F32)); // write the alpha U32 width = U2P(ALPHA_STRIDE); file.Write(&width, sizeof(U32)); U32 height = U2P(ALPHA_STRIDE); file.Write(&height, sizeof(U32)); if(k==0) { std::vector<U8>data(width*height); for(U32 j = 0; j < height; j++) { for( U32 i = 0; i < width; i++) { U8& alpha = layer.alpha[i+j*width]; U8& mask = mMask[i+j*width]; if(mask == 0) data[i+j*width] = (U8)(((F32)alpha)/255.0f*127.0f); else data[i+j*width] = (U8)(((F32)alpha)/255.0f*127.0f)+128; } } file.Write(&data[0], width*height*sizeof(U8)); } else { file.Write(&layer.alpha[0], width*height*sizeof(U8)); } } } UNGUARD; }
bool BufferInterface::allocMem()throw(BufferException) { if( mBufferInfo->isPingPongBuffer || //don't trust the bufferInfo dynamic_cast<PingPongBuffer*>(this) ) { throw(BufferException("Buffer::allocMem(): this routine may never be calles for ping pong buffers, as they are only managers" "for other buffers but having some own associated memory!")); } //assert that this routine is called only once per object: if(mCPU_Handle || mGraphicsBufferHandle || mComputeBufferHandle()) { throw(BufferException("Buffer::allocMem(): some buffers already allocated")); } if( mBufferInfo->usageContexts & HOST_CONTEXT_TYPE_FLAG ) { mCPU_Handle = malloc(mBufferInfo->bufferSizeInByte); } if(mBufferInfo->usageContexts & OPEN_GL_CONTEXT_TYPE_FLAG) { //ok, there is a need for an openGL buffer; maybe it will be shared with openCL, //but that doesn't matter for the GL buffer creation :) if( isDefaultBuffer() && (mBufferInfo->glBufferType == NO_GL_BUFFER_TYPE) ) { throw(BufferException("no gl buffer type specified for a non-texture or non-renderbuffer Buffer, although a gl usage context was requested")); } //no special treatment for texture types, as we use native GL-#defines GUARD(generateGL()); //"direct" call of "bindGL()" here isn't dangerous, as the buffer is not shared (yet), //as it has just been created; GUARD(bindGL()); GUARD(allocGL()); } //ok, the GL stuff is allocated if it was requested; Now let's check for the "compute" world; if(mBufferInfo->usageContexts & OPEN_CL_CONTEXT_TYPE_FLAG) { if(mBufferInfo->usageContexts & OPEN_GL_CONTEXT_TYPE_FLAG) { //both CL and GL are requested, that means interop: //neither bind nor alloc necessary, just generating: GUARD(generateCLGL()); } else { //a CL-only buffer is requested: //in OpenCL, alloc is done at the same time of generation; so, no allocCL() routine must be called GUARD(generateCL()); //GUARD(allocCL()); <--bullshaat ;) } } #if (FLEWNIT_TRACK_MEMORY || FLEWNIT_DO_PROFILING) //only track memory for non-pingpongs, as pingpongs only manage, but don't "own" own data store; if(! mBufferInfo->isPingPongBuffer) { registerBufferAllocation(mBufferInfo->usageContexts,mBufferInfo->bufferSizeInByte); } #endif return true; }
static int s2n_p_hash(union s2n_prf_working_space *ws, s2n_hmac_algorithm alg, struct s2n_blob *secret, struct s2n_blob *label, struct s2n_blob *seed_a, struct s2n_blob *seed_b, struct s2n_blob *out) { struct s2n_hmac_state *hmac = &ws->tls.hmac; uint32_t digest_size = s2n_hmac_digest_size(alg); /* First compute hmac(secret + A(0)) */ GUARD(s2n_hmac_init(hmac, alg, secret->data, secret->size)); GUARD(s2n_hmac_update(hmac, label->data, label->size)); GUARD(s2n_hmac_update(hmac, seed_a->data, seed_a->size)); if (seed_b) { GUARD(s2n_hmac_update(hmac, seed_b->data, seed_b->size)); } GUARD(s2n_hmac_digest(hmac, ws->tls.digest0, digest_size)); uint32_t outputlen = out->size; uint8_t *output = out->data; while (outputlen) { /* Now compute hmac(secret + A(N - 1) + seed) */ GUARD(s2n_hmac_reset(hmac)); GUARD(s2n_hmac_update(hmac, ws->tls.digest0, digest_size)); /* Add the label + seed and compute this round's A */ GUARD(s2n_hmac_update(hmac, label->data, label->size)); GUARD(s2n_hmac_update(hmac, seed_a->data, seed_a->size)); if (seed_b) { GUARD(s2n_hmac_update(hmac, seed_b->data, seed_b->size)); } GUARD(s2n_hmac_digest(hmac, ws->tls.digest1, digest_size)); uint32_t bytes_to_xor = MIN(outputlen, digest_size); for (int i = 0; i < bytes_to_xor; i++) { *output ^= ws->tls.digest1[i]; output++; outputlen--; } /* Stash a digest of A(N), in A(N), for the next round */ GUARD(s2n_hmac_reset(hmac)); GUARD(s2n_hmac_update(hmac, ws->tls.digest0, digest_size)); GUARD(s2n_hmac_digest(hmac, ws->tls.digest0, digest_size)); } return 0; }
const BufferInterface& BufferInterface::operator=(const BufferInterface& rhs) throw(BufferException) { //the buffers must match exactly in all their meta-info in order to be securely copied //OpenGL and OpenCL are less restrictve than me, but in this case, I trade flexibility //for simplicity and robustness; if( (*this) == rhs ) { if((mBufferInfo->usageContexts & HOST_CONTEXT_TYPE_FLAG) !=0) { memcpy(mCPU_Handle,rhs.getCPUBufferHandle(),mBufferInfo->bufferSizeInByte); } //GL if( ( hasBufferInContext(OPEN_GL_CONTEXT_TYPE) && PARA_COMP_MANAGER->graphicsAreInControl() ) || ! (hasBufferInContext(OPEN_CL_CONTEXT_TYPE)) ) { //commented out the guard in case of driver bugs fu**ing up when doing too mush time-shared CL-GL-stuff //TODO uncomment when stable work is assured //if(isCLGLShared()) { PARA_COMP_MANAGER->acquireSharedBuffersForGraphics(); } //do a barrier in by all means to assure buffer integrity; PARA_COMP_MANAGER->barrierGraphics(); GUARD(copyGLFrom(rhs.getGraphicsBufferHandle())); //return, as a shared buffer does need only copy via one context; return *this; } //CL if( ( hasBufferInContext(OPEN_CL_CONTEXT_TYPE) && PARA_COMP_MANAGER->computeIsInControl() ) || ! (hasBufferInContext(OPEN_GL_CONTEXT_TYPE)) ) { //commented out the guard in case of driver bugs fu**ing up when doing too mush time-shared CL-GL-stuff //TODO uncomment when stable work is assured //if(isCLGLShared()) { PARA_COMP_MANAGER->acquireSharedBuffersForCompute(); } //do a barrier in by all means to assure buffer integrity; PARA_COMP_MANAGER->barrierCompute(); GUARD(copyCLFrom(rhs.getComputeBufferHandle())); return *this; } } else { throw(BufferException("Buffer::operator= : Buffers not compatible")); } return *this; }
int s2n_stuffer_read_uint8(struct s2n_stuffer *stuffer, uint8_t *u) { GUARD(s2n_stuffer_read_bytes(stuffer, u, 1)); return 0; }
int main(int argc,char** argv){ // openssl support #ifdef _SSL initSSL(); ctx=SSL_CTX_new(SSLv23_client_method()); if(ctx==NULL){ ERR_print_errors_fp(stdout); exit(-2); } #endif if(argc!=2){ printf("Usage:client ipv6addr\n"); exit(-1); } setlocale(LC_ALL,""); char name[10]; printf("输入昵称:\n"); scanf("%6s",name); int sockfd,len; struct sockaddr_in6 dst; char buf[MAXBUF+1]; char buf1[MAXBUF+1]; sockfd=socket(AF_INET6,PROTOCOL,0); GUARD(sockfd); bzero(&dst,sizeof(dst)); dst.sin6_family=AF_INET6; dst.sin6_port=htons(SERVERPORT); GUARD(inet_pton(AF_INET6,argv[1],&dst.sin6_addr)); GUARD(connect(sockfd,(struct sockaddr *)&dst,sizeof(dst))); // ssl support #ifdef _SSL sslfd=SSL_new(ctx); SSL_set_fd(sslfd,sockfd); if(SSL_connect(sslfd)==-1) ERR_print_errors_fp(stderr); else{ printf("connected with %s encryption\n",SSL_get_cipher(sslfd)); //ShowCerts(sslfd); } #endif // ssl support bind over initscr(); WINDOW *recvBd=subwin(stdscr,HEIGHT1+2,WIDTH+2,1,1); WINDOW *inputBd=subwin(stdscr,HEIGHT+2,WIDTH+2,15,1); recvWin=subwin(stdscr,HEIGHT1,WIDTH,2,2); inputWin=subwin(stdscr,HEIGHT,WIDTH,16,2); box(recvBd,HLINE,VLINE); box(inputBd,HLINE,VLINE); wprintw(recvBd,"接收"); wprintw(inputBd,"发送"); cbreak(); keypad(stdscr,TRUE); start_color(); scrollok(recvWin,1); scrollok(inputWin,1); refresh(); bzero(buf,MAXBUF+1); #ifndef _SSL len=recv(sockfd,buf,MAXBUF,0); #else len=SSL_read(sslfd,buf,MAXBUF); #endif wprintw(recvWin,"%s\n",buf); touchwin(recvWin); wrefresh(recvWin); pthread_t t_recv; if(pthread_create(&t_recv,NULL,recvThread,(void*)sockfd)<0){ perror("create thread"); exit(1); } while(1){ bzero(buf,MAXBUF+1); wprintw(inputWin,"%6s > ",name); int key=wgetch(inputWin); if(key==ESCAPE){ break; } wscanw(inputWin,"%s",buf); touchwin(inputWin); wrefresh(inputWin); sprintf(buf1,"[%6s]: %c%s\n",name,(char)key,buf); #ifndef _SSL len=send(sockfd,buf1,strlen(buf1),0); #else len=SSL_write(sslfd,buf1,strlen(buf1)); #endif if(len<0) continue; } close(sockfd); delwin(recvWin); delwin(inputWin); delwin(recvBd); delwin(inputBd); endwin(); #ifdef _SSL SSL_shutdown(sslfd); SSL_free(sslfd); SSL_CTX_free(ctx); #endif return 0; }
int s2n_stuffer_write_uint8(struct s2n_stuffer *stuffer, const uint8_t u) { GUARD(s2n_stuffer_write_bytes(stuffer, &u, 1)); return 0; }
int main(int argc, char **argv) { uint8_t u8; uint16_t u16; uint32_t u32; uint32_t stuffer_size = nondet_uint32(); __CPROVER_assume(stuffer_size > 0); uint32_t entropy_size = nondet_uint32(); __CPROVER_assume(entropy_size > 0); uint8_t entropy[entropy_size]; struct s2n_stuffer stuffer; GUARD(s2n_stuffer_alloc(&stuffer, stuffer_size)); struct s2n_blob in = {.data = entropy,.size = entropy_size}; GUARD(s2n_stuffer_write(&stuffer, &in)); GUARD(s2n_stuffer_wipe(&stuffer)); while(nondet_bool()) { GUARD(s2n_stuffer_write_uint8(&stuffer, nondet_uint64())); } while(nondet_bool()) { GUARD(s2n_stuffer_read_uint8(&stuffer, &u8)); } GUARD(s2n_stuffer_wipe(&stuffer)); while(nondet_bool()) { GUARD(s2n_stuffer_write_uint16(&stuffer, nondet_uint64())); } while(nondet_bool()) { GUARD(s2n_stuffer_read_uint16(&stuffer, &u16)); } GUARD(s2n_stuffer_wipe(&stuffer)); while(nondet_bool()) { GUARD(s2n_stuffer_write_uint24(&stuffer, nondet_uint64())); } while(nondet_bool()) { GUARD(s2n_stuffer_read_uint24(&stuffer, &u32)); } GUARD(s2n_stuffer_wipe(&stuffer)); while(nondet_bool()) { GUARD(s2n_stuffer_write_uint32(&stuffer, nondet_uint64())); } while(nondet_bool()) { GUARD(s2n_stuffer_read_uint32(&stuffer, &u32)); } GUARD(s2n_stuffer_free(&stuffer)); }
// [[register]] SEXP unmelt(SEXP data, SEXP uniq_id, SEXP other_ind_, SEXP id_ind_, SEXP value_ind_) { // int id_ind = asInteger(id_ind_); int value_ind = asInteger(value_ind_); int* other_ind = INTEGER(other_ind_); int nRow = (int)(length(VECTOR_ELT(data, 0)) / length(uniq_id)); int numprotect = 0; if (TYPEOF(uniq_id) != STRSXP) { GUARD(uniq_id = coerceVector(uniq_id, STRSXP)); } int n_uniq = length(uniq_id); SEXP output; GUARD(output = allocVector(VECSXP, length(other_ind_) + length(uniq_id))); int n_other = length(other_ind_); // ensure that the unmelting process will go smoothly #define HANDLE_CASE(RTYPE, CTYPE, ACCESSOR) \ case RTYPE: { \ CTYPE* tmp = ACCESSOR( VECTOR_ELT(data, other_ind[i]) ); \ for (int j=0; j < nRow; ++j) { \ for (int k=1; k < n_uniq; ++k) { \ if (tmp[j] != tmp[j + nRow*k]) { \ Rf_error("Mismatch in elements at indices %i and %i in vector %s", j+1, j + nRow*k+1, CHAR(STRING_ELT(getAttrib(data, R_NamesSymbol), other_ind[i]))); \ } \ } \ } \ break; \ } \ if (n_uniq > 1) { for (int i=0; i < n_other; ++i) { switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) { HANDLE_CASE(LGLSXP, int, LOGICAL); HANDLE_CASE(INTSXP, int, INTEGER); HANDLE_CASE(REALSXP, double, REAL); HANDLE_CASE(STRSXP, SEXP, STRING_PTR); default: Rf_error("Unhandled type %s", type2char(TYPEOF(VECTOR_ELT(data, other_ind[i])))); } } } #undef HANDLE_CASE // copy in the 'other' variables first #define COPY(RTYPE, CTYPE, ACCESSOR) { \ PROTECT(tmp = allocVector(RTYPE, nRow)); \ CTYPE* tmp_ptr = ACCESSOR(tmp); \ CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, other_ind[i])); \ for (int i=0; i < nRow; ++i) { \ tmp_ptr[i] = data_ptr[i]; \ } \ SET_VECTOR_ELT(output, i, tmp); \ UNPROTECT(1); \ break; \ } \ SEXP tmp; for (int i=0; i < n_other; ++i) { switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) { case LGLSXP: COPY(LGLSXP, int, LOGICAL); case INTSXP: COPY(INTSXP, int, INTEGER); case REALSXP: COPY(REALSXP, double, REAL); case STRSXP: COPY(STRSXP, SEXP, STRING_PTR); default: Rf_error("Unhandled SEXP type"); } } #undef COPY #define COPY(RTYPE, CTYPE, ACCESSOR) { \ PROTECT(tmp = allocVector(RTYPE, nRow)); \ CTYPE* tmp_ptr = ACCESSOR(tmp); \ CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, value_ind)); \ for (int j=0; j < nRow; ++j) { \ tmp_ptr[j] = data_ptr[j + (i*nRow)]; \ } \ SET_VECTOR_ELT(output, i + n_other, tmp); \ UNPROTECT(1); \ break; \ } \ // copy the value int valuetype = TYPEOF(VECTOR_ELT(data, value_ind)); for (int i=0; i < n_uniq; ++i) { switch (valuetype) { case LGLSXP: COPY(LGLSXP, int, LOGICAL); case INTSXP: COPY(INTSXP, int, INTEGER); case REALSXP: COPY(REALSXP, double, REAL); case STRSXP: COPY(STRSXP, SEXP, STRING_PTR); } } // set the names SEXP datanames = getAttrib(data, R_NamesSymbol); SEXP names; GUARD(names = allocVector(STRSXP, n_other + n_uniq)); for (int i=0; i < n_other; ++i) { SET_STRING_ELT(names, i, STRING_ELT(datanames, i)); } for (int i=0; i < n_uniq; ++i) { SET_STRING_ELT(names, n_other+i, STRING_ELT(uniq_id, i)); } setAttrib(output, R_NamesSymbol, names); // set the class setAttrib(output, R_ClassSymbol, mkString("data.frame")); // set the rows SEXP rownames; GUARD( rownames=allocVector(INTSXP, nRow) ); int* rownames_ptr = INTEGER(rownames); for (int i=0; i < nRow; ++i) { rownames_ptr[i] = i+1; } setAttrib(output, R_RowNamesSymbol, rownames); UNGUARD; return output; }
int s2n_connection_wipe(struct s2n_connection *conn) { /* First make a copy of everything we'd like to save, which isn't very * much. */ int mode = conn->mode; struct s2n_config *config = conn->config; struct s2n_stuffer alert_in; struct s2n_stuffer reader_alert_out; struct s2n_stuffer writer_alert_out; struct s2n_stuffer handshake_io; struct s2n_stuffer header_in; struct s2n_stuffer in; struct s2n_stuffer out; /* Wipe all of the sensitive stuff */ GUARD(s2n_connection_free_keys(conn)); GUARD(s2n_stuffer_wipe(&conn->alert_in)); GUARD(s2n_stuffer_wipe(&conn->reader_alert_out)); GUARD(s2n_stuffer_wipe(&conn->writer_alert_out)); GUARD(s2n_stuffer_wipe(&conn->handshake.io)); GUARD(s2n_stuffer_wipe(&conn->header_in)); GUARD(s2n_stuffer_wipe(&conn->in)); GUARD(s2n_stuffer_wipe(&conn->out)); /* Allocate or resize to their original sizes */ GUARD(s2n_stuffer_resize(&conn->in, S2N_LARGE_FRAGMENT_LENGTH)); /* Allocate memory for handling handshakes */ GUARD(s2n_stuffer_resize(&conn->handshake.io, S2N_LARGE_RECORD_LENGTH)); /* Clone the stuffers */ /* ignore gcc 4.7 address warnings because dest is allocated on the stack */ /* pragma gcc diagnostic was added in gcc 4.6 */ #if defined(__GNUC__) && GCC_VERSION >= 40600 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Waddress" #endif memcpy_check(&alert_in, &conn->alert_in, sizeof(struct s2n_stuffer)); memcpy_check(&reader_alert_out, &conn->reader_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&writer_alert_out, &conn->writer_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&handshake_io, &conn->handshake.io, sizeof(struct s2n_stuffer)); memcpy_check(&header_in, &conn->header_in, sizeof(struct s2n_stuffer)); memcpy_check(&in, &conn->in, sizeof(struct s2n_stuffer)); memcpy_check(&out, &conn->out, sizeof(struct s2n_stuffer)); #if defined(__GNUC__) && GCC_VERSION >= 40600 #pragma GCC diagnostic pop #endif /* Zero the whole connection structure */ memset_check(conn, 0, sizeof(struct s2n_connection)); conn->readfd = -1; conn->writefd = -1; conn->mode = mode; conn->config = config; conn->active.cipher_suite = &s2n_null_cipher_suite; conn->pending.cipher_suite = &s2n_null_cipher_suite; conn->server = &conn->active; conn->client = &conn->active; conn->max_fragment_length = S2N_SMALL_FRAGMENT_LENGTH; conn->handshake.state = CLIENT_HELLO; GUARD(s2n_hash_init(&conn->handshake.client_md5, S2N_HASH_MD5)); GUARD(s2n_hash_init(&conn->handshake.client_sha1, S2N_HASH_SHA1)); GUARD(s2n_hash_init(&conn->handshake.client_sha256, S2N_HASH_SHA256)); GUARD(s2n_hash_init(&conn->handshake.server_md5, S2N_HASH_MD5)); GUARD(s2n_hash_init(&conn->handshake.server_sha1, S2N_HASH_SHA1)); GUARD(s2n_hash_init(&conn->handshake.server_sha256, S2N_HASH_SHA256)); GUARD(s2n_hmac_init(&conn->client->client_record_mac, S2N_HMAC_NONE, NULL, 0)); GUARD(s2n_hmac_init(&conn->server->server_record_mac, S2N_HMAC_NONE, NULL, 0)); memcpy_check(&conn->alert_in, &alert_in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->reader_alert_out, &reader_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&conn->writer_alert_out, &writer_alert_out, sizeof(struct s2n_stuffer)); memcpy_check(&conn->handshake.io, &handshake_io, sizeof(struct s2n_stuffer)); memcpy_check(&conn->header_in, &header_in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->in, &in, sizeof(struct s2n_stuffer)); memcpy_check(&conn->out, &out, sizeof(struct s2n_stuffer)); /* Set everything to the highest version at first */ conn->server_protocol_version = s2n_highest_protocol_version; conn->client_protocol_version = s2n_highest_protocol_version; conn->actual_protocol_version = s2n_highest_protocol_version; return 0; }
/* ==================== build ==================== */ VOID Capsule::build() { GUARD(Capsule::build); // clear the old keys mKeys.clear(); #define CAPSULE_SEGMENTS 20 #define CAPSULE_ROWS 10 std::vector<DVTN>vertexes; std::vector<U32>indexes; // create the capsule cylindrical body { const F32 angle_delta = 2.0f*PI/(F32)CAPSULE_SEGMENTS; const F32 texcoord_delta = 1.0f/(F32)CAPSULE_SEGMENTS; const F32 r = mRadius; const F32 h = mHeight; F32 base_z = -h*0.5f; F32 top_z = h*0.5f; F32 angle = 0.0f; F32 texcoord = 0.0f; for(U32 bodyi=0; bodyi<CAPSULE_SEGMENTS; ++bodyi,angle+=angle_delta,texcoord+=texcoord_delta) { F32 c = GMath::cos(angle); F32 s = GMath::sin(angle); DVTN v; v.normal[0] = c; v.normal[1] = s; v.normal[2] = 0.0f; v.texcoord[0] = texcoord; v.texcoord[1] = 1.0f; v.point[0] = c*r; v.point[1] = s*r; v.point[2] = top_z; vertexes.push_back(v); v.normal[0] = c; v.normal[1] = s; v.normal[2] = 0.0f; v.texcoord[0] = texcoord; v.texcoord[1] = 0.0f; v.point[0] = c*r; v.point[1] = s*r; v.point[2] = base_z; vertexes.push_back(v); } // do last point by hand to ensure no round off errors. DVTN v; v.normal[0] = 1.0f; v.normal[1] = 0.0f; v.normal[2] = 0.0f; v.texcoord[0] = 1.0f; v.texcoord[1] = 1.0f; v.point[0] = r; v.point[1] = 0.0f; v.point[2] = top_z; vertexes.push_back(v); v.normal[0] = 1.0f; v.normal[1] = 0.0f; v.normal[2] = 0.0f; v.texcoord[0] = 1.0f; v.texcoord[1] = 0.0f; v.point[0] = r; v.point[1] = 0.0f; v.point[2] = base_z; vertexes.push_back(v); // QUAD_STRIP U32 first = 0; U32 count = vertexes.size(); for(U32 i=3, pos=first;i<count;i+=2,pos+=2) { indexes.push_back(pos); indexes.push_back(pos+1); indexes.push_back(pos+2); indexes.push_back(pos+1); indexes.push_back(pos+3); indexes.push_back(pos+2); } } // create the capsule top cap { U32 count = vertexes.size(); F32 radius = mRadius; F32 z_offset = mHeight/2.0f; F32 l_delta = PI/(F32)CAPSULE_ROWS; F32 v_delta = 1.0f/(F32)CAPSULE_ROWS; F32 angle_delta = PI*2.0f/(F32)CAPSULE_SEGMENTS; F32 texcoord_horz_delta = 1.0f/(F32)CAPSULE_SEGMENTS; F32 l_base=-PI*0.5f + (l_delta*(CAPSULE_ROWS/2)); F32 r_base=(GMath::cos(l_base)*radius); F32 z_base=(GMath::sin(l_base)*radius); F32 v_base=(v_delta*(CAPSULE_ROWS/2)); F32 n_z_base=(GMath::sin(l_base)); F32 n_ratio_base=(GMath::cos(l_base)); U32 row_begin = CAPSULE_ROWS/2; U32 row_end = CAPSULE_ROWS; for(U32 rowi=row_begin; rowi<row_end; ++rowi) { F32 l_top = l_base+l_delta; F32 r_top = GMath::cos(l_top)*radius; F32 z_top = GMath::sin(l_top)*radius; F32 v_top = v_base+v_delta; F32 n_z_top= GMath::sin(l_top); F32 n_ratio_top= GMath::cos(l_top); F32 angle = 0.0f; F32 texcoord = 0.0f; // The only difference between the font & back face loops is that the // normals are inverted and the order of the vertex pairs is reversed. // The code is mostly duplicated in order to hoist the back/front face // test out of the loop for efficiency for(U32 topi=0; topi<CAPSULE_SEGMENTS;++topi,angle+=angle_delta,texcoord+=texcoord_horz_delta) { F32 c = GMath::cos(angle); F32 s = GMath::sin(angle); DVTN v; v.normal[0] = c*n_ratio_top; v.normal[1] = s*n_ratio_top; v.normal[2] = n_z_top; v.texcoord[0] = texcoord; v.texcoord[1] = v_top; v.point[0] = c*r_top; v.point[1] = s*r_top; v.point[2] = z_top+z_offset; vertexes.push_back(v); v.normal[0] = c*n_ratio_base; v.normal[1] = s*n_ratio_base; v.normal[2] = n_z_base; v.texcoord[0] = texcoord; v.texcoord[1] = v_base; v.point[0] = c*r_base; v.point[1] = s*r_base; v.point[2] = z_base+z_offset; vertexes.push_back(v); } // do last point by hand to ensure no round off errors. DVTN v; v.normal[0] = n_ratio_top; v.normal[1] = 0.0f; v.normal[2] = n_z_top; v.texcoord[0] = 1.0f; v.texcoord[1] = v_top; v.point[0] = r_top; v.point[1] = 0.0f; v.point[2] = z_top+z_offset; vertexes.push_back(v); v.normal[0] = n_ratio_base; v.normal[1] = 0.0f; v.normal[2] = n_z_base; v.texcoord[0] = 1.0f; v.texcoord[1] = v_base; v.point[0] = r_base; v.point[1] = 0.0f; v.point[2] = z_base+z_offset; vertexes.push_back(v); l_base=l_top; r_base=r_top; z_base=z_top; v_base=v_top; n_z_base=n_z_top; n_ratio_base=n_ratio_top; } // QUAD_STRIP U32 first = count; count = vertexes.size() - count; for(U32 i=3, pos=first;i<count;i+=2,pos+=2) { indexes.push_back(pos); indexes.push_back(pos+1); indexes.push_back(pos+2); indexes.push_back(pos+1); indexes.push_back(pos+3); indexes.push_back(pos+2); } } // create the capsule bottom cap { U32 count = vertexes.size(); F32 radius = mRadius; F32 z_offset = -mHeight/2.0f; F32 l_delta = PI/(F32)CAPSULE_ROWS; F32 v_delta = 1.0f/(F32)CAPSULE_ROWS; F32 angle_delta = PI*2.0f/(F32)CAPSULE_SEGMENTS; F32 texcoord_horz_delta = 1.0f/(F32)CAPSULE_SEGMENTS; F32 l_base=-PI*0.5f; F32 r_base=0.0f; F32 z_base=-radius; F32 v_base=0.0f; F32 n_z_base=-1.0f; F32 n_ratio_base=0.0f; U32 row_begin = 0; U32 row_end = CAPSULE_ROWS/2; for(U32 rowi=row_begin; rowi<row_end; ++rowi) { F32 l_top = l_base+l_delta; F32 r_top = GMath::cos(l_top)*radius; F32 z_top = GMath::sin(l_top)*radius; F32 v_top = v_base+v_delta; F32 n_z_top= GMath::sin(l_top); F32 n_ratio_top= GMath::cos(l_top); F32 angle = 0.0f; F32 texcoord = 0.0f; // The only difference between the font & back face loops is that the // normals are inverted and the order of the vertex pairs is reversed. // The code is mostly duplicated in order to hoist the back/front face // test out of the loop for efficiency for(U32 topi=0; topi<CAPSULE_SEGMENTS;++topi,angle+=angle_delta,texcoord+=texcoord_horz_delta) { F32 c = GMath::cos(angle); F32 s = GMath::sin(angle); DVTN v; v.normal[0] = c*n_ratio_top; v.normal[1] = s*n_ratio_top; v.normal[2] = n_z_top; v.texcoord[0] = texcoord; v.texcoord[1] = v_top; v.point[0] = c*r_top; v.point[1] = s*r_top; v.point[2] = z_top+z_offset; vertexes.push_back(v); v.normal[0] = c*n_ratio_base; v.normal[1] = s*n_ratio_base; v.normal[2] = n_z_base; v.texcoord[0] = texcoord; v.texcoord[1] = v_base; v.point[0] = c*r_base; v.point[1] = s*r_base; v.point[2] = z_base+z_offset; vertexes.push_back(v); } // do last point by hand to ensure no round off errors. DVTN v; v.normal[0] = n_ratio_top; v.normal[1] = 0.0f; v.normal[2] = n_z_top; v.texcoord[0] = 1.0f; v.texcoord[1] = v_top; v.point[0] = r_top; v.point[1] = 0.0f; v.point[2] = z_top+z_offset; vertexes.push_back(v); v.normal[0] = n_ratio_base; v.normal[1] = 0.0f; v.normal[2] = n_z_base; v.texcoord[0] = 1.0f; v.texcoord[1] = v_base; v.point[0] = r_base; v.point[1] = 0.0f; v.point[2] = z_base+z_offset; vertexes.push_back(v); l_base=l_top; r_base=r_top; z_base=z_top; v_base=v_top; n_z_base=n_z_top; n_ratio_base=n_ratio_top; } // QUAD_STRIP U32 first = count; count = vertexes.size() - count; for(U32 i=3, pos=first;i<count;i+=2,pos+=2) { indexes.push_back(pos); indexes.push_back(pos+1); indexes.push_back(pos+2); indexes.push_back(pos+1); indexes.push_back(pos+3); indexes.push_back(pos+2); } } // build the primitive mPrimitivePtr = GNEW(Primitive); CHECK(mPrimitivePtr); mPrimitivePtr->SetType(mType); // set the wvp Constant* wvp_constant_ptr = GNEW(Constant); CHECK(wvp_constant_ptr); wvp_constant_ptr->SetMatrix(Matrix()); mPrimitivePtr->SetConstant("gWVP",wvp_constant_ptr); // set the color Constant* color_constant_ptr = GNEW(Constant); CHECK(color_constant_ptr); color_constant_ptr->SetVector(Vector4(0,0,0,0)); mPrimitivePtr->SetConstant("gColor",color_constant_ptr); // set the shader Str key_name = "shader/color.xml"; KeyPtr key_ptr = Key::Find(key_name.c_str()); if(key_ptr == NULL) { Shader*shader = GNEW(Shader); CHECK(shader); shader->Load(GLoad(key_name.c_str())); key_ptr = GNEW(Key(key_name.c_str(), shader)); CHECK(key_ptr); } mKeys.push_back(key_ptr); mPrimitivePtr->SetShader(dynamic_cast<Shader*>(key_ptr->Ptr()), "p0"); // build the vertex buffer VertexBufferPtr vb_ptr = GNEW(VertexBuffer); CHECK(vb_ptr); { GDataPtr vd_ptr = GNEW(GData); CHECK(vd_ptr); vd_ptr->Size(3*sizeof(U32) + 4*sizeof(U8) + vertexes.size()*sizeof(DVTN)); U8*data_ptr = (U8*)vd_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','V','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = vertexes.size(); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(DVTN); data_ptr += sizeof(U32); *(U8*)data_ptr = 3; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_3F; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_2F; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_3F; data_ptr += sizeof(U8); ::memcpy(data_ptr, &vertexes[0], vertexes.size()*sizeof(DVTN)); data_ptr += vertexes.size()*sizeof(DVTN); vb_ptr->Load(vd_ptr.Ptr()); } mPrimitivePtr->SetVertexBuffer(vb_ptr.Ptr()); // build the index IndexBufferPtr ib_ptr = GNEW(IndexBuffer); CHECK(ib_ptr); { GDataPtr id_ptr = GNEW(GData); CHECK(id_ptr); id_ptr->Size(3*sizeof(U32) + indexes.size()*sizeof(U32)); U8*data_ptr = (U8*)id_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','I','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = indexes.size(); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(U32); data_ptr += sizeof(U32); ::memcpy(data_ptr, &indexes[0], indexes.size()*sizeof(U32)); data_ptr += indexes.size()*sizeof(U32); ib_ptr->Load(id_ptr.Ptr()); } mPrimitivePtr->SetIndexBuffer(ib_ptr.Ptr()); // build the bounding box mBox.set(MAX_F32,MAX_F32,MAX_F32,MIN_F32,MIN_F32,MIN_F32); for(U32 i = 0; i < vertexes.size(); i++)mBox.expand(vertexes[i].point); mPrimitivePtr->SetBox(mBox); UNGUARD; }
int64_t s2n_public_random(int64_t max) { uint64_t r; gt_check(max, 0); while(1) { struct s2n_blob blob = { .data = (void *) &r, sizeof(r) }; GUARD(s2n_get_public_random_data(&blob)); /* Imagine an int was one byte and UINT_MAX was 256. If the * caller asked for s2n_random(129, ...) we'd end up in * trouble. Each number in the range 0...127 would be twice * as likely as 128. That's because r == 0 % 129 -> 0, and * r == 129 % 129 -> 0, but only r == 128 returns 128, * r == 257 is out of range. * * To de-bias the dice, we discard values of r that are higher * that the highest multiple of 'max' an int can support. If * max is a uint, then in the worst case we discard 50% - 1 r's. * But since 'max' is an int and INT_MAX is <= UINT_MAX / 2, * in the worst case we discard 25% - 1 r's. */ if (r < (UINT64_MAX - (UINT64_MAX % max))) { return r % max; } } return -1; } #if !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_FIPS) && !defined(LIBRESSL_VERSION_NUMBER) int s2n_openssl_compat_rand(unsigned char *buf, int num) { struct s2n_blob out = {.data = buf, .size = num}; if(s2n_get_private_random_data(&out) < 0) { return 0; } return 1; } int s2n_openssl_compat_status(void) { return 1; } int s2n_openssl_compat_init(ENGINE *unused) { return 1; } RAND_METHOD s2n_openssl_rand_method = { .seed = NULL, .bytes = s2n_openssl_compat_rand, .cleanup = NULL, .add = NULL, .pseudorand = s2n_openssl_compat_rand, .status = s2n_openssl_compat_status }; #endif int s2n_init(void) { GUARD(s2n_mem_init()); OPEN: entropy_fd = open(ENTROPY_SOURCE, O_RDONLY); if (entropy_fd == -1) { if (errno == EINTR) { goto OPEN; } S2N_ERROR(S2N_ERR_OPEN_RANDOM); } #if defined(MAP_INHERIT_ZERO) zero_if_forked_ptr = mmap(NULL, sizeof(int), PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0); if (zero_if_forked_ptr == MAP_FAILED) { S2N_ERROR(S2N_ERR_OPEN_RANDOM); } if (minherit(zero_if_forked_ptr, sizeof(int), MAP_INHERIT_ZERO) == -1) { S2N_ERROR(S2N_ERR_OPEN_RANDOM); } #else if (pthread_atfork(NULL, NULL, s2n_on_fork) != 0) { S2N_ERROR(S2N_ERR_OPEN_RANDOM); } #endif GUARD(s2n_defend_if_forked()); #if !defined(OPENSSL_IS_BORINGSSL) && !defined(OPENSSL_FIPS) && !defined(LIBRESSL_VERSION_NUMBER) /* Create an engine */ ENGINE *e = ENGINE_new(); if (e == NULL || ENGINE_set_id(e, "s2n") != 1 || ENGINE_set_name(e, "s2n entropy generator") != 1 || ENGINE_set_flags(e, ENGINE_FLAGS_NO_REGISTER_ALL) != 1 || ENGINE_set_init_function(e, s2n_openssl_compat_init) != 1 || ENGINE_set_RAND(e, &s2n_openssl_rand_method) != 1 || ENGINE_add(e) != 1 || ENGINE_free(e) != 1) { S2N_ERROR(S2N_ERR_OPEN_RANDOM); } /* Use that engine for rand() */ e = ENGINE_by_id("s2n"); if (e == NULL || ENGINE_init(e) != 1 || ENGINE_set_default(e, ENGINE_METHOD_RAND) != 1) { S2N_ERROR(S2N_ERR_OPEN_RANDOM); } #endif return 0; }
/* ==================== build ==================== */ VOID Game::build() { GUARD(Game::build); // build the color texture Image* image = GNEW(Image); CHECK(image); image->Width(256); image->Height(256); image->Depth(1); image->PixelFormat(PF_RGBA); image->DataType(DT_UNSIGNED_BYTE); mColorTexPtr = GNEW(Texture); CHECK(mColorTexPtr); mColorTexPtr->Load(image); // build the color rt mColorRTPtr = GNEW(Target(mColorTexPtr.Ptr())); CHECK(mColorRTPtr); // build the primitive mQuadPtr = GNEW(Primitive); CHECK(mQuadPtr); mQuadPtr->SetType(Primitive::PT_TRIANGLES); // set the wvp Constant* wvp_constant_ptr = GNEW(Constant); CHECK(wvp_constant_ptr); wvp_constant_ptr->SetMatrix(Matrix()); mQuadPtr->SetConstant("gWVP",wvp_constant_ptr); // set the color texture Constant* texture_constant_ptr = GNEW(Constant); CHECK(texture_constant_ptr); texture_constant_ptr->SetTexture(mColorTexPtr.Ptr()); mQuadPtr->SetConstant("gBaseTex",texture_constant_ptr); // set the shader Str shader_key_name = "shader/default.xml"; KeyPtr shader_key_ptr = Key::Find(shader_key_name.c_str()); if(shader_key_ptr == NULL) { Shader*shader = GNEW(Shader); CHECK(shader); shader->Load(GLoad(shader_key_name.c_str())); shader_key_ptr = GNEW(Key(shader_key_name.c_str(), shader)); CHECK(shader_key_ptr); } mKeys.push_back(shader_key_ptr); mQuadPtr->SetShader(dynamic_cast<Shader*>(shader_key_ptr->Ptr()),"p0"); // build the vertex buffer F32 x = 0.0f, y = 0.0f, w = 256, h = 256; DVT vertexes[] = { {x, y, 0, 0, 0}, {x+w, y, 0, 1, 0}, {x+w, y+h, 0, 1, 1}, {x, y+h, 0, 0, 1}, }; VertexBufferPtr vb_ptr = GNEW(VertexBuffer); CHECK(vb_ptr); { GDataPtr vd_ptr = GNEW(GData); CHECK(vd_ptr); vd_ptr->Size(3*sizeof(U32) + 3*sizeof(U8) + sizeof(vertexes)); U8*data_ptr = (U8*)vd_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','V','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(vertexes)/sizeof(DVT); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(DVT); data_ptr += sizeof(U32); *(U8*)data_ptr = 2; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_3F; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_2F; data_ptr += sizeof(U8); ::memcpy(data_ptr, vertexes, sizeof(vertexes)); data_ptr += sizeof(vertexes); vb_ptr->Load(vd_ptr.Ptr()); } mQuadPtr->SetVertexBuffer(vb_ptr.Ptr()); // build the index const U16 indexes[] = { 3, 0, 2, 2, 0, 1 }; IndexBufferPtr ib_ptr = GNEW(IndexBuffer); CHECK(ib_ptr); { GDataPtr id_ptr = GNEW(GData); CHECK(id_ptr); id_ptr->Size(3*sizeof(U32) + sizeof(indexes)); U8*data_ptr = (U8*)id_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','I','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(indexes)/sizeof(U16); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(U16); data_ptr += sizeof(U32); ::memcpy(data_ptr, &indexes[0], sizeof(indexes)); data_ptr += sizeof(indexes); ib_ptr->Load(id_ptr.Ptr()); } mQuadPtr->SetIndexBuffer(ib_ptr.Ptr()); // build the bounding box BoundingBox box; box.set(MAX_F32,MAX_F32,MAX_F32,MIN_F32,MIN_F32,MIN_F32); for(U32 i = 0; i < sizeof(vertexes)/sizeof(DVTN); i++)box.expand(vertexes[i].point); mQuadPtr->SetBox(box); UNGUARD; }
int s2n_server_extensions_send(struct s2n_connection *conn, struct s2n_stuffer *out) { uint16_t total_size = 0; uint8_t application_protocol_len = strlen(conn->application_protocol); if (application_protocol_len) { total_size += 7 + application_protocol_len; } if (s2n_server_can_send_ocsp(conn)) { total_size += 4; } if (conn->secure_renegotiation) { total_size += 5; } if (conn->secure.cipher_suite->key_exchange_alg->flags & S2N_KEY_EXCHANGE_ECC) { total_size += 6; } if (total_size == 0) { return 0; } GUARD(s2n_stuffer_write_uint16(out, total_size)); /* Write the Supported Points Format extention. * RFC 4492 section 5.2 states that the absence of this extension in the Server Hello * is equivalent to allowing only the uncompressed point format. Let's send the * extension in case clients(Openssl 1.0.0) don't honor the implied behavior. */ if (conn->secure.cipher_suite->key_exchange_alg->flags & S2N_KEY_EXCHANGE_ECC) { GUARD(s2n_stuffer_write_uint16(out, TLS_EXTENSION_EC_POINT_FORMATS)); /* Total extension length */ GUARD(s2n_stuffer_write_uint16(out, 2)); /* Format list length */ GUARD(s2n_stuffer_write_uint8(out, 1)); /* Only uncompressed format is supported. Interoperability shouldn't be an issue: * RFC 4492 Section 5.1.2: Implementations must support it for all of their curves. */ GUARD(s2n_stuffer_write_uint8(out, TLS_EC_FORMAT_UNCOMPRESSED)); } /* Write the renegotiation_info extension */ if (conn->secure_renegotiation) { GUARD(s2n_stuffer_write_uint16(out, TLS_EXTENSION_RENEGOTIATION_INFO)); /* renegotiation_info length */ GUARD(s2n_stuffer_write_uint16(out, 1)); /* renegotiated_connection length. Zero since we don't support renegotiation. */ GUARD(s2n_stuffer_write_uint8(out, 0)); } /* Write ALPN extension */ if (application_protocol_len) { GUARD(s2n_stuffer_write_uint16(out, TLS_EXTENSION_ALPN)); GUARD(s2n_stuffer_write_uint16(out, application_protocol_len + 3)); GUARD(s2n_stuffer_write_uint16(out, application_protocol_len + 1)); GUARD(s2n_stuffer_write_uint8(out, application_protocol_len)); GUARD(s2n_stuffer_write_bytes(out, (uint8_t *) conn->application_protocol, application_protocol_len)); } /* Write OCSP extension */ if (s2n_server_can_send_ocsp(conn)) { GUARD(s2n_stuffer_write_uint16(out, TLS_EXTENSION_STATUS_REQUEST)); GUARD(s2n_stuffer_write_uint16(out, 0)); } return 0; }
/* ==================== Load ==================== */ VOID EChunk::Load(const VOID* data) { GUARD(EChunk::Load); // build the vertex buffer mVBPtr = GNEW(VertexBuffer); CHECK(mVBPtr); { DVT vertexes[] = { {0.0, 0.0, 0.0, 0.0, 1.0}, {CHUNK_STRIDE, 0.0, 0.0, 1.0, 1.0}, {CHUNK_STRIDE, CHUNK_STRIDE, 0.0, 1.0, 0.0}, {0.0, CHUNK_STRIDE, 0.0, 0.0, 0.0}, }; GDataPtr vd_ptr = GNEW(GData); CHECK(vd_ptr); vd_ptr->Size(3*sizeof(U32) + 3*sizeof(U8) + sizeof(vertexes)); U8*data_ptr = (U8*)vd_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','V','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(vertexes)/sizeof(DVT); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(DVT); data_ptr += sizeof(U32); *(U8*)data_ptr = 2; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_3F; data_ptr += sizeof(U8); *(U8*)data_ptr = VertexBuffer::VT_2F; data_ptr += sizeof(U8); ::memcpy(data_ptr, vertexes, sizeof(vertexes)); data_ptr += sizeof(vertexes); mVBPtr->Load(vd_ptr.Ptr()); } // build the index mIBPtr = GNEW(IndexBuffer); CHECK(mIBPtr); { const U16 indexes[] = { 3, 0, 2, 2, 0, 1 }; GDataPtr id_ptr = GNEW(GData); CHECK(id_ptr); id_ptr->Size(3*sizeof(U32) + sizeof(indexes)); U8*data_ptr = (U8*)id_ptr->Ptr(); *(U32*)data_ptr = MAKEFOURCC('G','I','B','O'); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(indexes)/sizeof(U16); data_ptr += sizeof(U32); *(U32*)data_ptr = sizeof(U16); data_ptr += sizeof(U32); ::memcpy(data_ptr, indexes, sizeof(indexes)); data_ptr += sizeof(indexes); mIBPtr->Load(id_ptr.Ptr()); } // build the shaders Str shader_name = "shader/chunk.xml"; mShaderKey = Key::Find(shader_name.c_str()); if(mShaderKey == NULL) { Shader*shader = GNEW(Shader); CHECK(shader); shader->Load(GLoad(shader_name.c_str())); mShaderKey = GNEW(Key(shader_name.c_str(), shader)); CHECK(mShaderKey); } // load the data U8*data_ptr = (U8*)data; // check the chunk header CHECK(*(U32*)data_ptr == (MAKEFOURCC('G','C','H','K'))); data_ptr += sizeof(U32); // get the layer U32 num_layer = *(U32*)data_ptr; data_ptr += sizeof(U32); for(U32 k = 0; k < num_layer; k++) { Layer layer; layer.total = 0; // get the primitive layer.primitive = GNEW(Primitive); CHECK(layer.primitive); layer.primitive->SetType(Primitive::PT_TRIANGLES); layer.primitive->SetVertexBuffer(mVBPtr.Ptr()); layer.primitive->SetIndexBuffer(mIBPtr.Ptr()); layer.primitive->SetConstant("gWVP",GNEW(Constant(Matrix()))); // get the color texture Str texture_name; U32 len = *(U32*)data_ptr; data_ptr += sizeof(U32); texture_name.resize(len, 0); memcpy(&texture_name[0], data_ptr, len*sizeof(CHAR)); data_ptr += len*sizeof(CHAR); KeyPtr texture_key_ptr = Key::Find(texture_name.c_str()); if(texture_key_ptr == NULL) { const Image* image = Image::Load(GLoad(texture_name.c_str())); CHECK(image); BaseTexture* base_texture = GNEW(Texture); CHECK(base_texture); base_texture->Load(image); texture_key_ptr = GNEW(Key(texture_name.c_str(), base_texture)); CHECK(texture_key_ptr); } mKeys.push_back(texture_key_ptr); layer.primitive->SetConstant("gColorTex",GNEW(Constant((BaseTexture*)texture_key_ptr->Ptr()))); layer.name = texture_name; // get the scale st F32 s = *(F32*)data_ptr; data_ptr += sizeof(F32); F32 t = *(F32*)data_ptr; data_ptr += sizeof(F32); layer.primitive->SetConstant("gScaleST",GNEW(Constant(Vector4(s,t,0,0)))); layer.st.set(s, t); // get the alpha U32 width = *(U32*)data_ptr; data_ptr += sizeof(U32); U32 height = *(U32*)data_ptr; data_ptr += sizeof(U32); if(width==U2P(ALPHA_STRIDE) && height==U2P(ALPHA_STRIDE)) { layer.alpha.resize(width*height*sizeof(U8)); ::memcpy(&layer.alpha[0], data_ptr, width*height*sizeof(U8)); data_ptr += width*height*sizeof(U8); } else { U8 alpha = *(U8*)data_ptr; data_ptr += sizeof(U8); width = U2P(ALPHA_STRIDE); height = U2P(ALPHA_STRIDE); layer.alpha.resize(width*height*sizeof(U8),alpha); } if(k==0) { mMask.resize(width*height); for(U32 j = 0; j < height; j++) { for( U32 i = 0; i < width; i++) { U8& alpha = layer.alpha[i+j*width]; U8& mask = mMask[i+j*width]; if(alpha <= 127) { alpha = (U8)((F32)alpha/127.0f*255.0f); mask = 0; } else { alpha = (U8)((F32)(alpha-128)/127.0f*255.0f); mask = 1; } layer.total += alpha; } } } else { for(U32 j = 0; j < height; j++) { for( U32 i = 0; i < width; i++) { layer.total += layer.alpha[i+j*width]; } } } BaseTexture *alpha_texture = GNEW(Texture); CHECK(alpha_texture); layer.primitive->SetConstant("gAlphaTex",GNEW(Constant(alpha_texture))); layer.texture = alpha_texture; // load the shader if(k==0) layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "base"); else layer.primitive->SetShader(dynamic_cast<Shader*>(mShaderKey->Ptr()), "layer"); // add the layer to the table mLayers.push_back(layer); } // update the layer Update(); UNGUARD; }