Java DataSource类代码示例

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Returns the contents of the APK's {@code AndroidManifest.xml} or {@code null} if this entry
 * is not present in the APK.
 */
static ByteBuffer getAndroidManifestFromApk(
        List<CentralDirectoryRecord> cdRecords, DataSource lhfSection)
                throws IOException, ApkFormatException, ZipFormatException {
    CentralDirectoryRecord androidManifestCdRecord = null;
    for (CentralDirectoryRecord cdRecord : cdRecords) {
        if (ANDROID_MANIFEST_ZIP_ENTRY_NAME.equals(cdRecord.getName())) {
            androidManifestCdRecord = cdRecord;
            break;
        }
    }
    if (androidManifestCdRecord == null) {
        throw new ApkFormatException("Missing " + ANDROID_MANIFEST_ZIP_ENTRY_NAME);
    }

    return ByteBuffer.wrap(
            LocalFileRecord.getUncompressedData(
                    lhfSection, androidManifestCdRecord, lhfSection.size()));
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
@Override
public OutputApkSigningBlockRequest outputZipSections(
        DataSource zipEntries,
        DataSource zipCentralDirectory,
        DataSource zipEocd)
                throws IOException, InvalidKeyException, SignatureException,
                        NoSuchAlgorithmException {
    checkNotClosed();
    checkV1SigningDoneIfEnabled();
    if (!mV2SigningEnabled) {
        return null;
    }
    invalidateV2Signature();

    byte[] apkSigningBlock =
            V2SchemeSigner.generateApkSigningBlock(
                    zipEntries, zipCentralDirectory, zipEocd, mV2SignerConfigs);

    mAddV2SignatureRequest = new OutputApkSigningBlockRequestImpl(apkSigningBlock);
    return mAddV2SignatureRequest;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Verifies the APK's signatures and returns the result of verification. The APK can be
 * considered verified iff the result's {@link Result#isVerified()} returns {@code true}.
 * The verification result also includes errors, warnings, and information about signers.
 *
 * @throws IOException if an I/O error is encountered while reading the APK
 * @throws ApkFormatException if the APK is malformed
 * @throws NoSuchAlgorithmException if the APK's signatures cannot be verified because a
 *         required cryptographic algorithm implementation is missing
 * @throws IllegalStateException if this verifier's configuration is missing required
 *         information.
 */
public Result verify() throws IOException, ApkFormatException, NoSuchAlgorithmException,
        IllegalStateException {
    Closeable in = null;
    try {
        DataSource apk;
        if (mApkDataSource != null) {
            apk = mApkDataSource;
        } else if (mApkFile != null) {
            RandomAccessFile f = new RandomAccessFile(mApkFile, "r");
            in = f;
            apk = DataSources.asDataSource(f, 0, f.length());
        } else {
            throw new IllegalStateException("APK not provided");
        }
        return verify(apk);
    } finally {
        if (in != null) {
            in.close();
        }
    }
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Outputs this record, replacing its extra field with the provided one, and returns returns the
 * number of bytes output.
 */
public long outputRecordWithModifiedExtra(
        DataSource sourceApk,
        ByteBuffer extra,
        DataSink output) throws IOException {
    long recordStartOffsetInSource = getStartOffsetInArchive();
    int extraStartOffsetInRecord = getExtraFieldStartOffsetInsideRecord();
    int extraSizeBytes = extra.remaining();
    int headerSize = extraStartOffsetInRecord + extraSizeBytes;
    ByteBuffer header = ByteBuffer.allocate(headerSize);
    header.order(ByteOrder.LITTLE_ENDIAN);
    sourceApk.copyTo(recordStartOffsetInSource, extraStartOffsetInRecord, header);
    header.put(extra.slice());
    header.flip();
    ZipUtils.setUnsignedInt16(header, EXTRA_LENGTH_OFFSET, extraSizeBytes);

    long outputByteCount = header.remaining();
    output.consume(header);
    long remainingRecordSize = getSize() - mDataStartOffset;
    sourceApk.feed(recordStartOffsetInSource + mDataStartOffset, remainingRecordSize, output);
    outputByteCount += remainingRecordSize;
    return outputByteCount;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Sends uncompressed data pointed to by the provided ZIP Central Directory (CD) record into the
 * provided data sink.
 */
public static void outputUncompressedData(
        DataSource source,
        CentralDirectoryRecord cdRecord,
        long cdStartOffsetInArchive,
        DataSink sink) throws ZipFormatException, IOException {
    // IMPLEMENTATION NOTE: This method attempts to mimic the behavior of Android platform
    // exhibited when reading an APK for the purposes of verifying its signatures.
    // When verifying an APK, Android doesn't care reading the extra field or the Data
    // Descriptor.
    LocalFileRecord lfhRecord =
            getRecord(
                    source,
                    cdRecord,
                    cdStartOffsetInArchive,
                    false, // don't care about the extra field
                    false // don't read the Data Descriptor
                    );
    lfhRecord.outputUncompressedData(source, sink);
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Returns the uncompressed data pointed to by the provided ZIP Central Directory (CD) record.
 */
public static byte[] getUncompressedData(
        DataSource source,
        CentralDirectoryRecord cdRecord,
        long cdStartOffsetInArchive) throws ZipFormatException, IOException {
    if (cdRecord.getUncompressedSize() > Integer.MAX_VALUE) {
        throw new IOException(
                cdRecord.getName() + " too large: " + cdRecord.getUncompressedSize());
    }
    byte[] result = new byte[(int) cdRecord.getUncompressedSize()];
    ByteBuffer resultBuf = ByteBuffer.wrap(result);
    ByteBufferSink resultSink = new ByteBufferSink(resultBuf);
    outputUncompressedData(
            source,
            cdRecord,
            cdStartOffsetInArchive,
            resultSink);
    return result;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Verifies the provided APK's APK Signature Scheme v2 signatures and returns the result of
 * verification. APK is considered verified only if {@link Result#verified} is {@code true}. If
 * verification fails, the result will contain errors -- see {@link Result#getErrors()}.
 *
 * @throws ApkFormatException if the APK is malformed
 * @throws NoSuchAlgorithmException if the APK's signatures cannot be verified because a
 *         required cryptographic algorithm implementation is missing
 * @throws SignatureNotFoundException if no APK Signature Scheme v2 signatures are found
 * @throws IOException if an I/O error occurs when reading the APK
 */
public static Result verify(DataSource apk, ApkUtils.ZipSections zipSections)
        throws IOException, ApkFormatException, NoSuchAlgorithmException,
                SignatureNotFoundException {
    Result result = new Result();
    SignatureInfo signatureInfo = findSignature(apk, zipSections, result);

    DataSource beforeApkSigningBlock = apk.slice(0, signatureInfo.apkSigningBlockOffset);
    DataSource centralDir =
            apk.slice(
                    signatureInfo.centralDirOffset,
                    signatureInfo.eocdOffset - signatureInfo.centralDirOffset);
    ByteBuffer eocd = signatureInfo.eocd;

    verify(beforeApkSigningBlock,
            signatureInfo.signatureBlock,
            centralDir,
            eocd,
            result);
    return result;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Returns the APK Signature Scheme v2 block contained in the provided APK file and the
 * additional information relevant for verifying the block against the file.
 *
 * @throws SignatureNotFoundException if the APK is not signed using APK Signature Scheme v2
 * @throws IOException if an I/O error occurs while reading the APK
 */
private static SignatureInfo findSignature(
        DataSource apk, ApkUtils.ZipSections zipSections, Result result)
                throws IOException, SignatureNotFoundException {
    // Find the APK Signing Block. The block immediately precedes the Central Directory.
    ByteBuffer eocd = zipSections.getZipEndOfCentralDirectory();
    Pair<DataSource, Long> apkSigningBlockAndOffset = findApkSigningBlock(apk, zipSections);
    DataSource apkSigningBlock = apkSigningBlockAndOffset.getFirst();
    long apkSigningBlockOffset = apkSigningBlockAndOffset.getSecond();
    ByteBuffer apkSigningBlockBuf =
            apkSigningBlock.getByteBuffer(0, (int) apkSigningBlock.size());
    apkSigningBlockBuf.order(ByteOrder.LITTLE_ENDIAN);

    // Find the APK Signature Scheme v2 Block inside the APK Signing Block.
    ByteBuffer apkSignatureSchemeV2Block =
            findApkSignatureSchemeV2Block(apkSigningBlockBuf, result);

    return new SignatureInfo(
            apkSignatureSchemeV2Block,
            apkSigningBlockOffset,
            zipSections.getZipCentralDirectoryOffset(),
            zipSections.getZipEndOfCentralDirectoryOffset(),
            eocd);
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
private ApkSigner(
        List<SignerConfig> signerConfigs,
        Integer minSdkVersion,
        boolean v1SigningEnabled,
        boolean v2SigningEnabled,
        boolean otherSignersSignaturesPreserved,
        String createdBy,
        ApkSignerEngine signerEngine,
        File inputApkFile,
        DataSource inputApkDataSource,
        File outputApkFile,
        DataSink outputApkDataSink,
        DataSource outputApkDataSource) {

    mSignerConfigs = signerConfigs;
    mMinSdkVersion = minSdkVersion;
    mV1SigningEnabled = v1SigningEnabled;
    mV2SigningEnabled = v2SigningEnabled;
    mOtherSignersSignaturesPreserved = otherSignersSignaturesPreserved;
    mCreatedBy = createdBy;

    mSignerEngine = signerEngine;

    mInputApkFile = inputApkFile;
    mInputApkDataSource = inputApkDataSource;

    mOutputApkFile = outputApkFile;
    mOutputApkDataSink = outputApkDataSink;
    mOutputApkDataSource = outputApkDataSource;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
private static void fulfillInspectInputJarEntryRequest(
        DataSource lfhSection,
        LocalFileRecord localFileRecord,
        ApkSignerEngine.InspectJarEntryRequest inspectEntryRequest)
                throws IOException, ApkFormatException {
    try {
        localFileRecord.outputUncompressedData(lfhSection, inspectEntryRequest.getDataSink());
    } catch (ZipFormatException e) {
        throw new ApkFormatException("Malformed ZIP entry: " + localFileRecord.getName(), e);
    }
    inspectEntryRequest.done();
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
private static long outputInputJarEntryLfhRecordPreservingDataAlignment(
        DataSource inputLfhSection,
        LocalFileRecord inputRecord,
        DataSink outputLfhSection,
        long outputOffset) throws IOException {
    long inputOffset = inputRecord.getStartOffsetInArchive();
    if (inputOffset == outputOffset) {
        // This record's data will be aligned same as in the input APK.
        return inputRecord.outputRecord(inputLfhSection, outputLfhSection);
    }
    int dataAlignmentMultiple = getInputJarEntryDataAlignmentMultiple(inputRecord);
    if ((dataAlignmentMultiple <= 1)
            || ((inputOffset % dataAlignmentMultiple)
                    == (outputOffset % dataAlignmentMultiple))) {
        // This record's data will be aligned same as in the input APK.
        return inputRecord.outputRecord(inputLfhSection, outputLfhSection);
    }

    long inputDataStartOffset = inputOffset + inputRecord.getDataStartOffsetInRecord();
    if ((inputDataStartOffset % dataAlignmentMultiple) != 0) {
        // This record's data is not aligned in the input APK. No need to align it in the
        // output.
        return inputRecord.outputRecord(inputLfhSection, outputLfhSection);
    }

    // This record's data needs to be re-aligned in the output. This is achieved using the
    // record's extra field.
    ByteBuffer aligningExtra =
            createExtraFieldToAlignData(
                    inputRecord.getExtra(),
                    outputOffset + inputRecord.getExtraFieldStartOffsetInsideRecord(),
                    dataAlignmentMultiple);
    return inputRecord.outputRecordWithModifiedExtra(
            inputLfhSection, aligningExtra, outputLfhSection);
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
private static ByteBuffer getZipCentralDirectory(
        DataSource apk,
        ApkUtils.ZipSections apkSections) throws IOException, ApkFormatException {
    long cdSizeBytes = apkSections.getZipCentralDirectorySizeBytes();
    if (cdSizeBytes > Integer.MAX_VALUE) {
        throw new ApkFormatException("ZIP Central Directory too large: " + cdSizeBytes);
    }
    long cdOffset = apkSections.getZipCentralDirectoryOffset();
    ByteBuffer cd = apk.getByteBuffer(cdOffset, (int) cdSizeBytes);
    cd.order(ByteOrder.LITTLE_ENDIAN);
    return cd;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Returns the minimum Android version (API Level) supported by the provided APK. This is based
 * on the {@code android:minSdkVersion} attributes of the APK's {@code AndroidManifest.xml}.
 */
private static int getMinSdkVersionFromApk(
        List<CentralDirectoryRecord> cdRecords, DataSource lhfSection)
                throws IOException, MinSdkVersionException {
    ByteBuffer androidManifest;
    try {
        androidManifest = getAndroidManifestFromApk(cdRecords, lhfSection);
    } catch (ZipFormatException | ApkFormatException e) {
        throw new MinSdkVersionException(
                "Failed to determine APK's minimum supported Android platform version",
                e);
    }
    return ApkUtils.getMinSdkVersionFromBinaryAndroidManifest(androidManifest);
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Sets the APK to be signed.
 *
 * @see #setInputApk(File)
 */
public Builder setInputApk(DataSource inputApk) {
    if (inputApk == null) {
        throw new NullPointerException("inputApk == null");
    }
    mInputApkDataSource = inputApk;
    mInputApkFile = null;
    return this;
}
 

import com.android.apksig.util.DataSource; //导入依赖的package包/类
/**
 * Sets the sink which will receive the output (signed) APK. Data received by the
 * {@code outputApkOut} sink must be visible through the {@code outputApkIn} data source.
 *
 * <p>This is an advanced variant of {@link #setOutputApk(ReadableDataSink)}, enabling the
 * sink and the source to be different objects.
 *
 * @see #setOutputApk(ReadableDataSink)
 * @see #setOutputApk(File)
 */
public Builder setOutputApk(DataSink outputApkOut, DataSource outputApkIn) {
    if (outputApkOut == null) {
        throw new NullPointerException("outputApkOut == null");
    }
    if (outputApkIn == null) {
        throw new NullPointerException("outputApkIn == null");
    }
    mOutputApkFile = null;
    mOutputApkDataSink = outputApkOut;
    mOutputApkDataSource = outputApkIn;
    return this;
}