1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
//
// Copyright (c) 2019-2020 Apple Inc. and the SwiftCrypto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
@_exported import CryptoKit
#else
/// An implementation of Secure Hashing Algorithm 2 (SHA-2) hashing with a
/// 256-bit digest.
///
/// The ``SHA256`` hash implements the ``HashFunction`` protocol for the
/// specific case of SHA-2 hashing with a 256-bit digest (``SHA256Digest``).
/// Larger digests take more space but are more secure.
///
/// You can compute the digest by calling the static ``hash(data:)`` method
/// once. Alternatively, if the data that you want to hash is too large to fit
/// in memory, you can compute the digest iteratively by creating a new hash
/// instance, calling the ``update(data:)`` method repeatedly with blocks of
/// data, and then calling the ``finalize()`` method to get the result.
public struct SHA256: HashFunctionImplementationDetails {
/// The number of bytes that represents the hash function’s internal state.
public static var blockByteCount: Int {
get { 64 }
set { fatalError("Cannot set SHA256.blockByteCount") }
}
/// The number of bytes in a SHA256 digest.
public static var byteCount: Int {
get { 32 }
set { fatalError("Cannot set SHA256.byteCount") }
}
/// The digest type for a SHA256 hash function.
public typealias Digest = SHA256Digest
var impl: DigestImpl<SHA256>
/// Creates a SHA256 hash function.
///
/// Initialize a new hash function by calling this method if you want to
/// hash data iteratively, such as when you don’t have a buffer large enough
/// to hold all the data at once. Provide data blocks to the hash function
/// using the ``update(data:)`` or ``update(bufferPointer:)`` method. After
/// providing all the data, call ``finalize()`` to get the digest.
///
/// If your data fits into a single buffer, you can use the ``hash(data:)``
/// method instead, to compute the digest in a single call.
public init() {
impl = DigestImpl()
}
// Once https://github.com/apple/swift-evolution/pull/910 is landed,
// we will be able to implement `init` here and remove the duplicate code.
/// Incrementally updates the hash function with the contents of the buffer.
///
/// Call this method one or more times to provide data to the hash function
/// in blocks. After providing the last block of data, call the
/// ``finalize()`` method to get the computed digest. Don’t call the update
/// method again after finalizing the hash function.
///
/// - Note: Typically, it’s safer to use an instance of
/// <doc://com.apple.documentation/documentation/foundation/data>, or some
/// other type that conforms to the
/// <doc://com.apple.documentation/documentation/foundation/dataprotocol>,
/// to hold your data. When possible, use the ``update(data:)`` method
/// instead.
///
/// - Parameters:
/// - bufferPointer: A pointer to the next block of data for the ongoing
/// digest calculation.
public mutating func update(bufferPointer: UnsafeRawBufferPointer) {
impl.update(data: bufferPointer)
}
/// Finalizes the hash function and returns the computed digest.
///
/// Call this method after you provide the hash function with all the data
/// to hash by making one or more calls to the ``update(data:)`` or
/// ``update(bufferPointer:)`` method. After finalizing the hash function,
/// discard it. To compute a new digest, create a new hash function with a
/// call to the ``init()`` method.
///
/// - Returns: The computed digest of the data.
public func finalize() -> Self.Digest {
return impl.finalize()
}
}
/// An implementation of Secure Hashing Algorithm 2 (SHA-2) hashing with a
/// 384-bit digest.
///
/// The ``SHA384`` hash implements the ``HashFunction`` protocol for the
/// specific case of SHA-2 hashing with a 384-bit digest (``SHA384Digest``).
/// Larger digests take more space but are more secure.
///
/// You can compute the digest by calling the static ``hash(data:)`` method
/// once. Alternatively, if the data that you want to hash is too large to fit
/// in memory, you can compute the digest iteratively by creating a new hash
/// instance, calling the ``update(data:)`` method repeatedly with blocks of
/// data, and then calling the ``finalize()`` method to get the result.
public struct SHA384: HashFunctionImplementationDetails {
/// The number of bytes that represents the hash function’s internal state.
public static var blockByteCount: Int {
get { 128 }
set { fatalError("Cannot set SHA384.blockByteCount") }
}
/// The number of bytes in a SHA384 digest.
public static var byteCount: Int {
get { 48 }
set { fatalError("Cannot set SHA384.byteCount") }
}
/// The digest type for a SHA384 hash function.
public typealias Digest = SHA384Digest
var impl: DigestImpl<SHA384>
/// Creates a SHA384 hash function.
///
/// Initialize a new hash function by calling this method if you want to
/// hash the data iteratively, such as when you don’t have a buffer large
/// enough to hold all the data at once. Provide data blocks to the hash
/// function using the ``update(data:)`` or ``update(bufferPointer:)``
/// method. After providing all the data, call ``finalize()`` to get the
/// digest.
///
/// If your data fits into a single buffer, you can use the ``hash(data:)``
/// method instead, to compute the digest in a single call.
public init() {
impl = DigestImpl()
}
// Once https://github.com/apple/swift-evolution/pull/910 is landed,
// we will be able to implement `init` here and remove the duplicate code.
/// Incrementally updates the hash function with the contents of the buffer.
///
/// Call this method one or more times to provide data to the hash function
/// in blocks. After providing the last block of data, call the
/// ``finalize()`` method to get the computed digest. Don’t call the update
/// method again after finalizing the hash function.
///
/// - Note: Typically, it’s safer to use an instance of
/// <doc://com.apple.documentation/documentation/foundation/data>, or some
/// other type that conforms to the
/// <doc://com.apple.documentation/documentation/foundation/dataprotocol>,
/// to hold your data. When possible, use the ``update(data:)`` method
/// instead.
///
/// - Parameters:
/// - bufferPointer: A pointer to the next block of data for the ongoing
/// digest calculation.
public mutating func update(bufferPointer: UnsafeRawBufferPointer) {
impl.update(data: bufferPointer)
}
/// Finalizes the hash function and returns the computed digest.
///
/// Call this method after you provide the hash function with all the data
/// to hash by making one or more calls to the ``update(data:)`` or
/// ``update(bufferPointer:)`` method. After finalizing the hash function,
/// discard it. To compute a new digest, create a new hash function with a
/// call to the ``init()`` method.
///
/// - Returns: The computed digest of the data.
public func finalize() -> Self.Digest {
return impl.finalize()
}
}
/// An implementation of Secure Hashing Algorithm 2 (SHA-2) hashing with a
/// 512-bit digest.
///
/// The ``SHA512`` hash implements the ``HashFunction`` protocol for the
/// specific case of SHA-2 hashing with a 512-bit digest (``SHA512Digest``).
/// Larger digests take more space but are more secure.
///
/// You can compute the digest by calling the static ``hash(data:)`` method
/// once. Alternatively, if the data that you want to hash is too large to fit
/// in memory, you can compute the digest iteratively by creating a new hash
/// instance, calling the ``update(data:)`` method repeatedly with blocks of
/// data, and then calling the ``finalize()`` method to get the result.
public struct SHA512: HashFunctionImplementationDetails {
/// The number of bytes that represents the hash function’s internal state.
public static var blockByteCount: Int {
get { 128 }
set { fatalError("Cannot set SHA512.blockByteCount") }
}
/// The number of bytes in a SHA512 digest.
public static var byteCount: Int {
get { 64 }
set { fatalError("Cannot set SHA512.byteCount") }
}
/// The digest type for a SHA512 hash function.
public typealias Digest = SHA512Digest
var impl: DigestImpl<SHA512>
/// Creates a SHA512 hash function.
///
/// Initialize a new hash function by calling this method if you want to
/// hash the data iteratively, such as when you don’t have a buffer large
/// enough to hold all the data at once. Provide data blocks to the hash
/// function using the ``update(data:)`` or ``update(bufferPointer:)``
/// method. After providing all the data, call ``finalize()`` to get the
/// digest.
///
/// If your data fits into a single buffer, you can use the ``hash(data:)``
/// method instead, to compute the digest in a single call.
public init() {
impl = DigestImpl()
}
/// Incrementally updates the hash function with the contents of the buffer.
///
/// Call this method one or more times to provide data to the hash function
/// in blocks. After providing the last block of data, call the
/// ``finalize()`` method to get the computed digest. Don’t call the update
/// method again after finalizing the hash function.
///
/// - Note: Typically, it’s safer to use an instance of
/// <doc://com.apple.documentation/documentation/foundation/data>, or some
/// other type that conforms to the
/// <doc://com.apple.documentation/documentation/foundation/dataprotocol>,
/// to hold your data. When possible, use the ``update(data:)`` method
/// instead.
///
/// - Parameters:
/// - bufferPointer: A pointer to the next block of data for the ongoing
/// digest calculation.
public mutating func update(bufferPointer: UnsafeRawBufferPointer) {
impl.update(data: bufferPointer)
}
/// Finalizes the hash function and returns the computed digest.
///
/// Call this method after you provide the hash function with all the data
/// to hash by making one or more calls to the ``update(data:)`` or
/// ``update(bufferPointer:)`` method. After finalizing the hash function,
/// discard it. To compute a new digest, create a new hash function with a
/// call to the ``init()`` method.
///
/// - Returns: The computed digest of the data.
public func finalize() -> Self.Digest {
return impl.finalize()
}
}
#endif // Linux or !SwiftPM
|