Blowfish::Blowfish(const byte *key_string, unsigned int keylength, CipherDir dir) : pbox(ROUNDS+2), sbox(4*256) { assert(keylength == KeyLength(keylength)); unsigned i, j=0, k; word32 data, dspace[2] = {0, 0}; memcpy(pbox, p_init, sizeof(p_init)); memcpy(sbox, s_init, sizeof(s_init)); // Xor key string into encryption key vector for (i=0 ; i<ROUNDS+2 ; ++i) { data = 0 ; for (k=0 ; k<4 ; ++k ) data = (data << 8) | key_string[j++ % keylength]; pbox[i] ^= data; } crypt_block(dspace, pbox); for (i=0; i<ROUNDS; i+=2) crypt_block(pbox+i, pbox+i+2); crypt_block(pbox+ROUNDS, sbox); for (i=0; i<4*256-2; i+=2) crypt_block(sbox+i, sbox+i+2); if (dir==DECRYPTION) for (i=0; i<(ROUNDS+2)/2; i++) std::swap(pbox[i], pbox[ROUNDS+1-i]); }
RC6Base::RC6Base(const byte *k, unsigned int keylen, unsigned int rounds) : r(rounds), sTable((2*r)+4) { assert(keylen == KeyLength(keylen)); static const RC6_WORD MAGIC_P = 0xb7e15163L; // magic constant P for wordsize static const RC6_WORD MAGIC_Q = 0x9e3779b9L; // magic constant Q for wordsize static const int U=sizeof(RC6_WORD); const unsigned int c=(keylen-1)/U + 1; SecBlock<RC6_WORD> l(c); GetUserKeyLittleEndian(l.ptr, c, k, keylen); sTable[0] = MAGIC_P; for (unsigned j=1; j<sTable.size;j++) sTable[j] = sTable[j-1] + MAGIC_Q; RC6_WORD a=0, b=0; const unsigned n = 3*STDMAX(sTable.size,c); for (unsigned h=0; h < n; h++) { a = sTable[h % sTable.size] = rotlFixed((sTable[h % sTable.size] + a + b), 3); b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b)); } }
void CipherInit(Cipher_CTX* ctx, uint8_t mode, const uint8_t* key, const uint8_t* IV) { memset(ctx, 0, sizeof(Cipher_CTX)); memcpy(ctx->key, key, KeyLength(mode)); ctx->mode = mode; ctx->blocksize = CipherBlockSize(mode); if (IV) memcpy(ctx->feedback, IV, ctx->blocksize); }
Rijndael::Rijndael(const byte *userKey, unsigned int keylen) : k_len(keylen/4), key(k_len*5 + 24) { assert(keylen == KeyLength(keylen)); word32 t; int i; GetUserKeyLittleEndian(key.ptr, k_len, userKey, keylen); switch(k_len) { case 4: t = key[3]; for(i = 0; i < 10; ++i) { t = rotrFixed(t, 8); t = ls_box(t) ^ rco_tab[i]; key[4 * i + 4] = t ^= key[4 * i]; key[4 * i + 5] = t ^= key[4 * i + 1]; key[4 * i + 6] = t ^= key[4 * i + 2]; key[4 * i + 7] = t ^= key[4 * i + 3]; } break; case 6: t = key[5]; for(i = 0; i < 8; ++i) { t = rotrFixed(t, 8); t = ls_box(t) ^ rco_tab[i]; key[6 * i + 6] = t ^= key[6 * i]; key[6 * i + 7] = t ^= key[6 * i + 1]; key[6 * i + 8] = t ^= key[6 * i + 2]; key[6 * i + 9] = t ^= key[6 * i + 3]; key[6 * i + 10] = t ^= key[6 * i + 4]; key[6 * i + 11] = t ^= key[6 * i + 5]; } break; case 8: t = key[7]; for(i = 0; i < 7; ++i) { t = rotrFixed(t, 8); t = ls_box(t) ^ rco_tab[i]; key[8 * i + 8] = t ^= key[8 * i]; key[8 * i + 9] = t ^= key[8 * i + 1]; key[8 * i + 10] = t ^= key[8 * i + 2]; key[8 * i + 11] = t ^= key[8 * i + 3]; key[8 * i + 12] = t = key[8 * i + 4] ^ ls_box(t); \ key[8 * i + 13] = t ^= key[8 * i + 5]; key[8 * i + 14] = t ^= key[8 * i + 6]; key[8 * i + 15] = t ^= key[8 * i + 7]; } break; } }
void SHARKBase::InitEncryptionRoundKeys(const byte *key, unsigned int keyLen, unsigned int rounds, word64 *roundkeys) { assert(keyLen == KeyLength(keyLen)); // concatenate key enought times to fill a for (unsigned int i=0; i<(rounds+1)*8; i++) ((byte *)roundkeys)[i] = key[i%keyLen]; SHARKEncryption e; byte IV[8] = {0,0,0,0,0,0,0,0}; CFBEncryption cfb(e, IV); cfb.ProcessString((byte *)roundkeys, (rounds+1)*8); #ifdef IS_LITTLE_ENDIAN byteReverse(roundkeys, roundkeys, (rounds+1)*8); #endif roundkeys[rounds] = SHARKTransform(roundkeys[rounds]); }
void GrGLProgramDesc::Build(const GrDrawState& drawState, bool isPoints, GrDrawState::BlendOptFlags blendOpts, GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff, const GrGpuGL* gpu, const GrDeviceCoordTexture* dstCopy, SkTArray<const GrEffectStage*, true>* colorStages, SkTArray<const GrEffectStage*, true>* coverageStages, GrGLProgramDesc* desc) { colorStages->reset(); coverageStages->reset(); // This should already have been caught SkASSERT(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts)); bool skipCoverage = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag); bool skipColor = SkToBool(blendOpts & (GrDrawState::kEmitTransBlack_BlendOptFlag | GrDrawState::kEmitCoverage_BlendOptFlag)); int firstEffectiveColorStage = 0; bool inputColorIsUsed = true; if (!skipColor) { firstEffectiveColorStage = drawState.numColorStages(); while (firstEffectiveColorStage > 0 && inputColorIsUsed) { --firstEffectiveColorStage; const GrEffect* effect = drawState.getColorStage(firstEffectiveColorStage).getEffect()->get(); inputColorIsUsed = effect->willUseInputColor(); } } int firstEffectiveCoverageStage = 0; bool inputCoverageIsUsed = true; if (!skipCoverage) { firstEffectiveCoverageStage = drawState.numCoverageStages(); while (firstEffectiveCoverageStage > 0 && inputCoverageIsUsed) { --firstEffectiveCoverageStage; const GrEffect* effect = drawState.getCoverageStage(firstEffectiveCoverageStage).getEffect()->get(); inputCoverageIsUsed = effect->willUseInputColor(); } } // The descriptor is used as a cache key. Thus when a field of the // descriptor will not affect program generation (because of the attribute // bindings in use or other descriptor field settings) it should be set // to a canonical value to avoid duplicate programs with different keys. bool requiresColorAttrib = !skipColor && drawState.hasColorVertexAttribute(); bool requiresCoverageAttrib = !skipCoverage && drawState.hasCoverageVertexAttribute(); // we only need the local coords if we're actually going to generate effect code bool requiresLocalCoordAttrib = !(skipCoverage && skipColor) && drawState.hasLocalCoordAttribute(); bool colorIsTransBlack = SkToBool(blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag); bool colorIsSolidWhite = (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) || (!requiresColorAttrib && 0xffffffff == drawState.getColor()) || (!inputColorIsUsed); int numEffects = (skipColor ? 0 : (drawState.numColorStages() - firstEffectiveColorStage)) + (skipCoverage ? 0 : (drawState.numCoverageStages() - firstEffectiveCoverageStage)); size_t newKeyLength = KeyLength(numEffects); bool allocChanged; desc->fKey.reset(newKeyLength, SkAutoMalloc::kAlloc_OnShrink, &allocChanged); if (allocChanged || !desc->fInitialized) { // make sure any padding in the header is zero if we we haven't used this allocation before. memset(desc->header(), 0, kHeaderSize); } // write the key length *desc->atOffset<uint32_t, kLengthOffset>() = SkToU32(newKeyLength); KeyHeader* header = desc->header(); EffectKey* effectKeys = desc->effectKeys(); int currEffectKey = 0; bool readsDst = false; bool readFragPosition = false; bool hasVertexCode = false; if (!skipColor) { for (int s = firstEffectiveColorStage; s < drawState.numColorStages(); ++s) { effectKeys[currEffectKey++] = get_key_and_update_stats(drawState.getColorStage(s), gpu->glCaps(), requiresLocalCoordAttrib, &readsDst, &readFragPosition, &hasVertexCode); } } if (!skipCoverage) { for (int s = firstEffectiveCoverageStage; s < drawState.numCoverageStages(); ++s) { effectKeys[currEffectKey++] = get_key_and_update_stats(drawState.getCoverageStage(s), gpu->glCaps(), requiresLocalCoordAttrib, &readsDst, &readFragPosition, &hasVertexCode); } } header->fHasVertexCode = hasVertexCode || requiresLocalCoordAttrib; header->fEmitsPointSize = isPoints; // Currently the experimental GS will only work with triangle prims (and it doesn't do anything // other than pass through values from the VS to the FS anyway). #if GR_GL_EXPERIMENTAL_GS #if 0 header->fExperimentalGS = gpu->caps().geometryShaderSupport(); #else header->fExperimentalGS = false; #endif #endif bool defaultToUniformInputs = GR_GL_NO_CONSTANT_ATTRIBUTES || gpu->caps()->pathRenderingSupport(); if (colorIsTransBlack) { header->fColorInput = kTransBlack_ColorInput; } else if (colorIsSolidWhite) { header->fColorInput = kSolidWhite_ColorInput; } else if (defaultToUniformInputs && !requiresColorAttrib) { header->fColorInput = kUniform_ColorInput; } else { header->fColorInput = kAttribute_ColorInput; header->fHasVertexCode = true; } bool covIsSolidWhite = !requiresCoverageAttrib && 0xffffffff == drawState.getCoverageColor(); if (skipCoverage) { header->fCoverageInput = kTransBlack_ColorInput; } else if (covIsSolidWhite || !inputCoverageIsUsed) { header->fCoverageInput = kSolidWhite_ColorInput; } else if (defaultToUniformInputs && !requiresCoverageAttrib) { header->fCoverageInput = kUniform_ColorInput; } else { header->fCoverageInput = kAttribute_ColorInput; header->fHasVertexCode = true; } if (readsDst) { SkASSERT(NULL != dstCopy || gpu->caps()->dstReadInShaderSupport()); const GrTexture* dstCopyTexture = NULL; if (NULL != dstCopy) { dstCopyTexture = dstCopy->texture(); } header->fDstReadKey = GrGLShaderBuilder::KeyForDstRead(dstCopyTexture, gpu->glCaps()); SkASSERT(0 != header->fDstReadKey); } else { header->fDstReadKey = 0; } if (readFragPosition) { header->fFragPosKey = GrGLShaderBuilder::KeyForFragmentPosition(drawState.getRenderTarget(), gpu->glCaps()); } else { header->fFragPosKey = 0; } // Record attribute indices header->fPositionAttributeIndex = drawState.positionAttributeIndex(); header->fLocalCoordAttributeIndex = drawState.localCoordAttributeIndex(); // For constant color and coverage we need an attribute with an index beyond those already set int availableAttributeIndex = drawState.getVertexAttribCount(); if (requiresColorAttrib) { header->fColorAttributeIndex = drawState.colorVertexAttributeIndex(); } else if (GrGLProgramDesc::kAttribute_ColorInput == header->fColorInput) { SkASSERT(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt); header->fColorAttributeIndex = availableAttributeIndex; availableAttributeIndex++; } else { header->fColorAttributeIndex = -1; } if (requiresCoverageAttrib) { header->fCoverageAttributeIndex = drawState.coverageVertexAttributeIndex(); } else if (GrGLProgramDesc::kAttribute_ColorInput == header->fCoverageInput) { SkASSERT(availableAttributeIndex < GrDrawState::kMaxVertexAttribCnt); header->fCoverageAttributeIndex = availableAttributeIndex; } else { header->fCoverageAttributeIndex = -1; } // Here we deal with whether/how we handle color and coverage separately. // Set this default and then possibly change our mind if there is coverage. header->fCoverageOutput = kModulate_CoverageOutput; // If we do have coverage determine whether it matters. bool separateCoverageFromColor = false; if (!drawState.isCoverageDrawing() && !skipCoverage && (drawState.numCoverageStages() > 0 || requiresCoverageAttrib)) { if (gpu->caps()->dualSourceBlendingSupport() && !(blendOpts & (GrDrawState::kEmitCoverage_BlendOptFlag | GrDrawState::kCoverageAsAlpha_BlendOptFlag))) { if (kZero_GrBlendCoeff == dstCoeff) { // write the coverage value to second color header->fCoverageOutput = kSecondaryCoverage_CoverageOutput; separateCoverageFromColor = true; } else if (kSA_GrBlendCoeff == dstCoeff) { // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered. header->fCoverageOutput = kSecondaryCoverageISA_CoverageOutput; separateCoverageFromColor = true; } else if (kSC_GrBlendCoeff == dstCoeff) { // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered. header->fCoverageOutput = kSecondaryCoverageISC_CoverageOutput; separateCoverageFromColor = true; } } else if (readsDst && kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff) { header->fCoverageOutput = kCombineWithDst_CoverageOutput; separateCoverageFromColor = true; } } if (!skipColor) { for (int s = firstEffectiveColorStage; s < drawState.numColorStages(); ++s) { colorStages->push_back(&drawState.getColorStage(s)); } } if (!skipCoverage) { SkTArray<const GrEffectStage*, true>* array; if (separateCoverageFromColor) { array = coverageStages; } else { array = colorStages; } for (int s = firstEffectiveCoverageStage; s < drawState.numCoverageStages(); ++s) { array->push_back(&drawState.getCoverageStage(s)); } } header->fColorEffectCnt = colorStages->count(); header->fCoverageEffectCnt = coverageStages->count(); *desc->checksum() = 0; *desc->checksum() = SkChecksum::Compute(reinterpret_cast<uint32_t*>(desc->fKey.get()), newKeyLength); desc->fInitialized = true; }
void GrGLProgramDesc::setRandom(SkRandom* random, const GrGpuGL* gpu, const GrRenderTarget* dstRenderTarget, const GrTexture* dstCopyTexture, const GrEffectStage* stages[], int numColorStages, int numCoverageStages, int currAttribIndex) { int numEffects = numColorStages + numCoverageStages; size_t keyLength = KeyLength(numEffects); fKey.reset(keyLength); *this->atOffset<uint32_t, kLengthOffset>() = static_cast<uint32_t>(keyLength); memset(this->header(), 0, kHeaderSize); KeyHeader* header = this->header(); header->fEmitsPointSize = random->nextBool(); header->fPositionAttributeIndex = 0; // if the effects have used up all off the available attributes, // don't try to use color or coverage attributes as input do { header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>( random->nextULessThan(kColorInputCnt)); } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex && kAttribute_ColorInput == header->fColorInput); header->fColorAttributeIndex = (header->fColorInput == kAttribute_ColorInput) ? currAttribIndex++ : -1; do { header->fCoverageInput = static_cast<GrGLProgramDesc::ColorInput>( random->nextULessThan(kColorInputCnt)); } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex && kAttribute_ColorInput == header->fCoverageInput); header->fCoverageAttributeIndex = (header->fCoverageInput == kAttribute_ColorInput) ? currAttribIndex++ : -1; #if GR_GL_EXPERIMENTAL_GS header->fExperimentalGS = gpu->caps()->geometryShaderSupport() && random->nextBool(); #endif bool useLocalCoords = random->nextBool() && currAttribIndex < GrDrawState::kMaxVertexAttribCnt; header->fLocalCoordAttributeIndex = useLocalCoords ? currAttribIndex++ : -1; header->fColorEffectCnt = numColorStages; header->fCoverageEffectCnt = numCoverageStages; bool dstRead = false; bool fragPos = false; bool vertexCode = false; int numStages = numColorStages + numCoverageStages; for (int s = 0; s < numStages; ++s) { const GrBackendEffectFactory& factory = (*stages[s]->getEffect())->getFactory(); GrDrawEffect drawEffect(*stages[s], useLocalCoords); this->effectKeys()[s] = factory.glEffectKey(drawEffect, gpu->glCaps()); if ((*stages[s]->getEffect())->willReadDstColor()) { dstRead = true; } if ((*stages[s]->getEffect())->willReadFragmentPosition()) { fragPos = true; } if ((*stages[s]->getEffect())->hasVertexCode()) { vertexCode = true; } } if (dstRead) { header->fDstReadKey = GrGLShaderBuilder::KeyForDstRead(dstCopyTexture, gpu->glCaps()); } else { header->fDstReadKey = 0; } if (fragPos) { header->fFragPosKey = GrGLShaderBuilder::KeyForFragmentPosition(dstRenderTarget, gpu->glCaps()); } else { header->fFragPosKey = 0; } header->fHasVertexCode = vertexCode || useLocalCoords || kAttribute_ColorInput == header->fColorInput || kAttribute_ColorInput == header->fCoverageInput; CoverageOutput coverageOutput; bool illegalCoverageOutput; do { coverageOutput = static_cast<CoverageOutput>(random->nextULessThan(kCoverageOutputCnt)); illegalCoverageOutput = (!gpu->caps()->dualSourceBlendingSupport() && CoverageOutputUsesSecondaryOutput(coverageOutput)) || (!dstRead && kCombineWithDst_CoverageOutput == coverageOutput); } while (illegalCoverageOutput); header->fCoverageOutput = coverageOutput; *this->checksum() = 0; *this->checksum() = SkChecksum::Compute(reinterpret_cast<uint32_t*>(fKey.get()), keyLength); fInitialized = true; }