Sha3 hash generator

Sample Programs

There are five sample programs. The first prints information about the hash. The second creates a hash using SHA3-256 class. The third creates a hash using a pipeline. The fourth and fifth examples show how to verify an existing digest.

The examples below use SHA3-256, but you can swap-in any hash function, like PanamaHash or SM3.

The first example dumps the name, digest size and internal block size of the hash.

#include "cryptlib.h"
#include "sha3.h"
#include <iostream>

int main (int argc, char* argv[])
{
    using namespace CryptoPP;

    SHA3_256 hash;	
    std::cout << "Name: " << hash.AlgorithmName() << std::endl;
    std::cout << "Digest size: " << hash.DigestSize() << std::endl;
    std::cout << "Block size: " << hash.BlockSize() << std::endl;

    return 0; 
}

Running the program results in the following. In general you should use and avoid . is usually not required by a program. In the case of SHA3 the block size is the rate .

$ ./test.exe
Name: SHA3-256
Digest size: 32
Block size: 136

The second example creates a hash using the hash object and member functions. You add data using and you calculate the hash using . Calling resets the hash so you don’t need to do it manually.

using namespace CryptoPP;
HexEncoder encoder(new FileSink(std::cout));

std::string msg = "Yoda said, Do or do not. There is no try.";
std::string digest;

SHA3_256 hash;
hash.Update((const byte*)msg.data(), msg.size());
digest.resize(hash.DigestSize());
hash.Final((byte*)&digest);

std::cout << "Message: " << msg << std::endl;

std::cout << "Digest: ";
StringSource(digest, true, new Redirector(encoder));
std::cout << std::endl;

Running the program results in the following.

$ ./test.exe
Message: Yoda said, Do or do not. There is no try.
Digest: 18CEA61486D217DCDC19246FA28BBD32660CEC3771442B5C2AB93271D32B2797

You can also obtain a truncated hash rather than the full hash using .

std::cout << "Message: " << msg << std::endl;

hash.Update((const byte*)msg.data(), msg.size());
digest.resize(hash.DigestSize()/2);
hash.TruncatedFinal((byte*)&digest, digest.size());

std::cout << "Digest: ";
StringSource(digest, true, new Redirector(encoder));
std::cout << std::endl;

The program produces the following result.

$ ./test.exe
Message: Yoda said, Do or do not. There is no try.
Digest: 18CEA61486D217DCDC19246FA28BBD32

Using a pipeline produces the same result. It relieves you of calling and Final manually. The code also uses a , which has its own wiki page at HashFilter.

std::string msg = "Yoda said, Do or do not. There is no try.";
std::string digest;

StringSource(msg, true, new HashFilter(hash, new StringSink(digest)));

std::cout << "Message: " << msg << std::endl;

std::cout << "Digest: ";
StringSource(digest, true, new Redirector(encoder));
std::cout << std::endl;

Running the program results in the following.

$ ./test.exe
Message: Yoda said, Do or do not. There is no try.
Digest: 18CEA61486D217DCDC19246FA28BBD32660CEC3771442B5C2AB93271D32B2797

The fourth program verifies an existing hash using the hash object. Notice the program proceeds as if the hash is going to be calculated. But rather than calling to retrieve the hash, is called to verify the existing hash.

SHA3_256 hash;
hash.Update((const byte*)msg.data(), msg.size());
bool verified = hash.Verify((const byte*)digest.data());

if (verified == true)
    std::cout << "Verified hash over message" << std::endl;
else
    std::cout << "Failed to verify hash over message" << std::endl;

The final program verifies an existing hash using a pipeline. The code uses a , which has its own wiki page at HashVerificationFilter.

bool result;
StringSource(digest+msg, true, new HashVerificationFilter(hash,
                 new ArraySink((byte*)&result, sizeof(result))));

if (result == true)
    std::cout << "Verified hash over message" << std::endl;
else
    std::cout << "Failed to verify hash over message" << std::endl;

Running the program results in the following output.

$ ./test.exe
Message: Yoda said, Do or do not. There is no try.
Digest: 18CEA61486D217DCDC19246FA28BBD32660CEC3771442B5C2AB93271D32B2797
Verified hash over message

Алгоритм

Хеш-функции семейства SHA-3 построены на основе конструкции криптографической губки, в которой данные сначала «впитываются» в губку, при котором исходное сообщение M{\displaystyle M} подвергается многораундовым перестановкам f{\displaystyle f}, затем результат Z{\displaystyle Z} «отжимается» из губки. На этапе «впитывания» блоки сообщения суммируются по модулю 2 с подмножеством состояния, после чего всё состояние преобразуется с помощью функции перестановки f{\displaystyle f}. На этапе «отжимания» выходные блоки считываются из одного и того же подмножества состояния, изменённого функцией перестановок f{\displaystyle f}. Размер части состояния, который записывается и считывается, называется «скоростью» (англ. rate) и обозначается r{\displaystyle r}, а размер части, которая нетронута вводом / выводом, называется «ёмкостью» (англ. capacity) и обозначается c{\displaystyle c}.

Алгоритм получения значения хеш-функции можно разделить на несколько этапов:

• Исходное сообщение M{\displaystyle M} дополняется до строки P{\displaystyle P} длины, кратной r{\displaystyle r}, с помощью функции дополнения (pad-функции);
• Строка P{\displaystyle P} делится на n{\displaystyle n} блоков длины r{\displaystyle r}: P,P1,…,Pn−1{\displaystyle P_{0},P_{1},…,P_{n-1}};
• «Впитывание»: каждый блок Pi{\displaystyle P_{i}} дополняется нулями до строки длины b{\displaystyle b} бит и суммируется по модулю 2 со строкой состояния S{\displaystyle S}, где S{\displaystyle S} — строка длины b{\displaystyle b} бит (b{\displaystyle b} = r{\displaystyle r} + c{\displaystyle c}). Перед началом работы функции все элементы S{\displaystyle S} равны нулю. Для каждого следующего блока состояние — строка, полученная применением функции перестановок f{\displaystyle f} к результату предыдущего шага;
• «Отжимание»: пока длина Z{\displaystyle Z} меньше d{\displaystyle d} (d{\displaystyle d} — количество бит в результате хеш-функции), к Z{\displaystyle Z} добавляется r{\displaystyle r} первых бит состояния S{\displaystyle S}, после каждого прибавления к S{\displaystyle S} применяется функция перестановок f{\displaystyle f}. Затем Z{\displaystyle Z} обрезается до длины d{\displaystyle d} бит;
• Строка Z{\displaystyle Z} длины d{\displaystyle d} бит возвращается в качестве результата.

Благодаря тому, что состояние содержит c{\displaystyle c} дополнительных бит, алгоритм устойчив к атаке удлинением сообщения, к которой восприимчивы алгоритмы SHA-1 и SHA-2.

В SHA-3 состояние S{\displaystyle S} — это массив 5 × 5 слов длиной w{\displaystyle w} = 64 бита, всего 5 × 5 × 64 = 1600 бит. Также в Keccak могут использоваться длины w{\displaystyle w}, равные меньшим степеням 2 (от w{\displaystyle w} = 1 до w{\displaystyle w} = 32).

Usage

You can use this library from Node.js, from web browsers, and/or using ES6 imports.

Node.js (CommonJS style)

// Standard FIPS 202 SHA-3 implementation
const { SHA3 } = require('sha3');

// The Keccak hash function is also available
const { Keccak } = require('sha3');

ES6

// Standard FIPS 202 SHA-3 implementation
import { SHA3 } from 'sha3';

// The Keccak hash function is also available
import { Keccak } from 'sha3';

What’s in the box

FIPS-compatible interfaces for the following algorithms:

• : The SHA3 algorithm.
• : The Keccak algorithm.
• : The SHAKE XOF algorithm.

Examples

Generating a SHAKE128 hash with 2048 bytes

import { SHAKE } from 'sha3';

const hash = new SHAKE(128);

hash.update('foo');
hash.digest({ buffer: Buffer.alloc(2048), format: 'hex' });

API Reference

All hash implementations provided by this library conform to the following API specification.

The constructor for each hash (e.g: , ), expects the following parameters:

size (Number): Optional. The size of the hash to create, in bits. If provided, this must be one of 224, 256, 384, or 512. Defaults to 512.

Example

// Construct a new Keccak hash of size 256
const hash = new Keccak(256);

Updates the hash content with the given data. Returns the hash object itself.

• (Buffer|string): Required. The data to read into the hash.
• (string): Optional. The encoding of the given , if of type . Defaults to .

Example

const hash = new Keccak(256);

hash.update('hello');

hash.update('we can also chain these').update('together');

Digests the hash and returns the result. After calling this function, the hash may continue to receive input.

encoding (string): Optional. The encoding to use for the returned digest. Defaults to ‘binary’.

If an is provided and is a value other than , then this function returns a .
Otherwise, it returns a .

Example

const hash = new Keccak(256);

hash.update('hello');

hash.digest('hex');
// => hash of 'hello' as a hex-encoded string

Digests the hash and returns the result. After calling this function, the hash may continue to receive input.

Options include:

• (Buffer): Optional. A pre-allocated buffer to fill with output bytes. This is how XOF algorithms like SHAKE can be used to obtain an arbitrary number of hash bytes.
• (string): Optional. The encoding to use for the returned digest. Defaults to . If is also provided, this value will passed directly into on the given buffer.
• (byte): Optional. Override the padding used to pad the input bytes to the algorithm’s block size. Typically this should be omitted, but may be required if building additional cryptographic algorithms on top of this library.

If a is provided and is a value other than , then this function returns a .
Otherwise, it returns a .

Example

const hash = new Keccak(256);

hash.update('hello');

hash.digest({ buffer: Buffer.alloc(32), format: 'hex' });
// => hash of 'hello' as a hex-encoded string

Resets a hash to its initial state.

• All input buffers are cleared from memory.
• The hash object can safely be reused to compute another hash.

Example

const hash = new Keccak(256);

hash.update('hello');
hash.digest();
// => hash of 'hello'

hash.reset();

hash.update('world');
hash.digest();
// => hash of 'world'

Блок перестановки

Блочное преобразование f , которое представляет собой Keccak-f для SHA-3, представляет собой перестановку, которая использует операции , AND и NOT , и предназначена для простой реализации как в программном, так и в аппаратном обеспечении.

Она определяется для любой мощности из-двух слов размера, W = 2 л битов. В основной передаче SHA-3 используются 64-битные слова, ℓ = 6 .

Состояние можно рассматривать как массив бит 5 × 5 × w . Пусть a [ i ] [  j ] [ k ] будет битом (5 i + j ) × w + k входных данных, используя соглашение о нумерации битов с прямым порядком байтов и индексирование по старшим строкам . Т.е. я выбирает строку, j столбец и k бит.

Индексная арифметика выполняется по модулю 5 для первых двух измерений и по модулю w для третьего.

Базовая функция перестановки блоков состоит из 12 + 2 ℓ раундов по пять шагов:

θ (тета)

Вычислите четность каждого из 5 w (320, когда w = 64 ) 5-битных столбцов, а также четность двух соседних столбцов в обычном шаблоне. Чтобы быть точным, a [ i ] [  j ] [ k ] ← a [ i ] [  j ] [ k ] четность (a [  j −1] [ k ]] »⊕ четность (a [  j +1] [ k −1])

ρ (ро)

Побитовое вращение каждого из 25 слов на другое треугольное число 0, 1, 3, 6, 10, 15, …. Чтобы быть точным, a не вращается, и для всех 0 ≤ t < 24 , a [ i ] [  j ] [ k ] ← a [ i ] [  j ] [ k — ( t +1) ( t +2) / 2] » , где .(яj)знак равно(321)т(1){\ displaystyle {\ begin {pmatrix} i \\ j \ end {pmatrix}} = {\ begin {pmatrix} 3 & 2 \\ 1 & 0 \ end {pmatrix}} ^ {t} {\ begin {pmatrix} 0 \\ 1 \ end {pmatrix}}}

π (пи)

Переставьте 25 слов в фиксированном порядке. a [3 i +2 j ] [ i ] ← a [  i ] [ j ] .

χ (чи)

Побитовое объединение по строкам, используя x ← x ⊕ (¬ y & z ) . Чтобы быть точным, a [ i ] [  j ] [ k ] ← a [ i ] [  j ] [ k ] ⊕ (¬ a [ i ] [  j + 1 ] [ k ] & a [ i ] [  j + 2 ] » [ k ]) . Это единственная нелинейная операция в SHA-3.

ι (йота)

Эксклюзивная или округленная константа в одно слово состояния. Чтобы быть точными, в круглом п , для 0 ≤ т ≤ л , [2 м -1] является операция XOR с битом м + 7 п градуса 8- LFSR последовательности. Это нарушает симметрию, сохраняемую на других этапах.

Сравнение функций SHA

В таблице ниже внутреннее состояние означает «внутреннюю хеш-сумму» после каждого сжатия блока данных.

В столбце поразрядных операций «Rot» обозначает , а «Shr» обозначает . Все эти алгоритмы тем или иным образом используют за исключением SHA-3.

Более подробные измерения производительности на современных архитектурах процессоров приведены в таблице ниже.

Номера производительности с пометкой «x86» выполнялись с использованием 32-битного кода на 64-битных процессорах, тогда как номера «x86-64» — это собственный 64-битный код. Хотя SHA-256 предназначен для 32-битных вычислений, он действительно выигрывает от кода, оптимизированного для 64-битных процессоров на архитектуре x86. 32-битные реализации SHA-512 значительно медленнее своих 64-битных аналогов. Варианты обоих алгоритмов с разными размерами вывода будут работать одинаково, поскольку функции раскрытия и сжатия сообщений идентичны, и различаются только начальные значения хеш-функции и размеры вывода. Лучшие реализации MD5 и SHA-1 выполняют от 4,5 до 6 циклов на байт на современных процессорах.

Тестирование проводилось Иллинойским университетом в Чикаго на их системе Hydra8, работающей на Intel Xeon E3-1275 V2 с тактовой частотой 3,5 ГГц, и на их системе Hydra9 с APU AMD A10-5800K с тактовой частотой 3,8 ГГц. Указанные выше скорости циклов на байт являются средней производительностью алгоритма, обрабатывающего сообщение размером 4096 байт с использованием программного обеспечения для криптографического тестирования SUPERCOP. Производительность в мегабайтах в секунду экстраполируется из тактовой частоты процессора на одном ядре; реальная производительность будет зависеть от множества факторов.

Implementation

Example of a Smart contract hashing being able to trustlessly Keccak-256 hash a hypothetical block header.

Here is an analysis of Monero’s nonce-distribution for «cryptonight», an algorithm similar to Ethash, which also attempts to be «ASIC-Resistant» it is very clear in the picture that before the hashing algorithm is changed there is a clear nonce-pattern. This is indicative of a major failure in a hashing algorithm, and should illustrate the dangers of disregarding proper cryptographic security. Finding a hashing pattern would be far harder using a proven system like Keccak-256:

1. The Proof of work function needs to be replaced with Keccak-256
2. The Function that checks the nonce-header in the block needs to know to accept Keccak-256 hashes as valid for a block.

• Node Implementation (based on Parity). Located here
• Keccak-256 CPU Miner. Located here

Дополнительные функции[править | править код]

В декабре 2016 года Национальный институт стандартов и технологий США опубликовал новый документ, NIST SP.800-185, описывающий дополнительные функции на основе SHA-3:

Настройки

Оригинальный алгоритм Keccak имеет множество настраиваемых параметров с целью обеспечения оптимального соотношения криптостойкости и быстродействия для определённого применения алгоритма на определённой платформе. Настраиваемыми величинами являются: размер блока данных, размер состояния алгоритма, количество раундов в функции f() и другие.

На протяжения конкурса хеширования Национального института стандартов и технологий участники имели право настраивать свои алгоритмы для решения возникших проблем. Так, были внесены некоторые изменения в Keccak: количество раундов было увеличено с 18 до 24 с целью увеличения запаса безопасности.

Авторы Keccak учредили ряд призов за достижения в криптоанализе данного алгоритма.

Версия алгоритма, принятая в качестве окончательного стандарта SHA-3, имеет несколько незначительных отличий от оригинального предложения Keccak на конкурс. В частности, были ограничены некоторые параметры (отброшены медленные режимы c=768 и c=1024), в том числе для увеличения производительности. Также в стандарте были введены «функции с удлиняемым результатом» (XOF, Extendable Output Functions) SHAKE128 и SHAKE256, для чего хешируемое сообщение стало необходимо дополнять «суффиксом» из 2 или 4 бит, в зависимости от типа функции.

Примеры вариантов SHA-3

Следующие хеш-значения взяты с сайта NIST.gov:

SHA3-224("") 6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7 SHA3-256("") a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a SHA3-384("") 0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004 SHA3-512("") a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26 SHAKE128("", 256) 7f9c2ba4e88f827d616045507605853ed73b8093f6efbc88eb1a6eacfa66ef26 SHAKE256("", 512) 46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762fd75dc4ddd8c0f200cb05019d67b592f6fc821c49479ab48640292eacb3b7c4be 

Изменение одного бита приводит к тому, что каждый бит на выходе изменяется с вероятностью 50%, демонстрируя лавинный эффект :

SHAKE128("The quick brown fox jumps over the lazy dog", 256) f4202e3c5852f9182a0430fd8144f0a74b95e7417ecae17db0f8cfeed0e3e66e SHAKE128("The quick brown fox jumps over the lazy dof", 256) 853f4538be0db9621a6cea659a06c1107b1f83f02b13d18297bd39d7411cf10c 

Дополнительные функции

В декабре 2016 года Национальный институт стандартов и технологий США опубликовал новый документ, NIST SP.800-185, описывающий дополнительные функции на основе SHA-3:

история

В 2004 году произошло несколько прорывов в атаках на широко используемые в то время хеш-функции, такие как MD5 (практические коллизии) и SHA-1 (теоретические коллизии с большими усилиями). Среди прочего, были обнаружены фундаментальные недостатки конструкции Меркла-Дамгарда , которые снижают вычислительные затраты для определенных сценариев атаки (хотя и не обязательно до такой степени, что атака будет практически осуществима). Семейство SHA-2 действительно существует, против которого еще не было никаких практических атак, но эти функции — как и их предшественники MD4 , MD5 и SHA-1 — являются конструкциями Меркла-Дамгарда с функциями сжатия Дэвиса-Мейера. Высказывались опасения, что атаки на эти предшественники могут быть преобразованы в атаки на SHA-2. Если SHA-2 окажется уязвимым или небезопасным, не будет стандартизированной криптологической хеш-функции, признанной безопасной. Поэтому было решено создать новый стандарт, учитывающий текущие исследования и более ориентированный на будущее, чем SHA-2.

Подобно выбору блочного шифрования AES ( Advanced Encryption Standard ), NIST провел конкурс с ноября 2007 года по октябрь 2012 года. Представленные хеш-функции должны были хешировать сообщения до верхнего предела не менее битов и поддерживать по крайней мере четыре длины хеширования: 224, 256, 384 и 512 бит. Участвующие команды криптографов представили 64 хэш-функции, 51 из которых соответствовали требованиям для входа и были допущены к 1 раунду. После анализа безопасности и производительности в открытом процессе оценки, в котором приняли участие криптологи со всего мира, для второго раунда было отобрано 14 кандидатов.
264-1{\ displaystyle 2 ^ {64} -1}

В каждом раунде конкурса участникам разрешалось вносить изменения в свои алгоритмы, чтобы отреагировать на результаты анализа. В случае Keccak количество раундов функции перестановки было увеличено с 18 до 24 для большего запаса прочности, а длина блоков сообщений для некоторых вариантов была увеличена, что повысило эффективность.

В декабре 2010 года были объявлены пять финалистов: BLAKE , Grøstl , JH , Keccak и Skein . Keccak был объявлен победителем 2 октября 2012 года и с тех пор именуется SHA-3.

SHA-3 имеет высокий резерв криптографической безопасности и также может быть эффективно реализован на оборудовании. Простая и элегантная структура, облегчающая криптоанализ , также имеет преимущество . Однако есть один критический момент: производительность программной реализации довольно низкая по сравнению с другими финалистами. Утверждалось, что NIST уделяет слишком много внимания аппаратным реализациям.

стандартизация

Сотрудник NIST Джон Келси в августе 2013 года на «Семинаре по криптографическому оборудованию и встроенным системам 2013» (CHES 2013) предложил стандартизировать только два уровня безопасности: 128 бит и 256 бит. Емкость c должна быть уменьшена до 256 бит для меньших вариантов SHA3-224 и SHA3-256 и до 512 бит для двух больших. Это увеличивает скорость выполнения, поскольку длина r блока сообщения соответственно больше, а количество обрабатываемых блоков сообщений меньше. Атака архетипа все равно будет по крайней мере такой же сложной, как атака столкновения, на которую изменение не повлияет.

Некоторые исследователи раскритиковали это снижение безопасности и раскритиковали процесс последующего изменения победителя конкурса, так что это больше не будет тщательно исследованным оригинальным алгоритмом. Авторы Keccak, с другой стороны, отстаивали предложенные изменения.

В ответ на критику NIST решил не уменьшать емкость четырех вариантов, SHA3-224, до SHA3-512. В этом нет необходимости, поскольку варианты SHAKE128 и SHAKE256 с разрядностью 256 или 512 бит также стандартизированы. За исключением длины хэша, свободно выбираемой пользователем, они соответствуют предлагаемым версиям с уменьшенной емкостью и, таким образом, обеспечивают такую ​​же эффективность.

По умолчанию

В августе 2015 года NIST стандартизировал следующие версии SHA3 (вся информация в битах):

Варианты SHAKE128 и SHAKE256 представляют собой так называемые расширяемые функции вывода (XOF; функции с расширяемым выводом ). Длина хеш-значения заранее не фиксируется, но любое количество хеш-данных может быть извлечено после того, как сообщение было включено в блок данных. После того, как были взяты каждые 1344 или 1088 бит, блок данных снова переставляется, как описано выше. Эти варианты работают как криптографически безопасные генераторы псевдослучайных чисел с хешированным сообщением в качестве начального числа.

Чтобы варианты SHA3 и SHAKE имели разные хеши, была изменена схема развёртывания сообщений. С SHA3 добавляется битовая последовательность 011, а с SHAKE, однако, 11111, перед заполнением 0 битами и 1 битом в конце. Таким образом достигается разделение домена: после расширения вы можете увидеть в сообщении, каким из двух способов он был расширен. Два сообщения, которые раскрываются по-разному, в каждом случае различаются. При выборе этих методов заполнения также учитывалась более поздняя стандартизация других хэш-процессов на основе Keccak (например, хэш-процессы дерева ).

Это изменение заполнения не влияет на эффективность, если сообщение состоит из целых байтов, что почти всегда имеет место на практике. Длина блока сообщения r также кратна восьми и, следовательно, количеству свободных битов в последнем блоке. Либо дополнительный блок сообщения должен быть добавлен для битов заполнения в любом случае, либо по крайней мере один байт свободен в последнем блоке, который может полностью разместить биты заполнения. По сравнению с исходным заполнением Keccak количество блоков сообщений ни в коем случае не увеличивается.

В декабре 2016 года NIST опубликовал документ, в котором описаны другие хэш-процессы, производные от SHA-3. Каждый из них доступен в двух версиях с 256-битной и 512-битной емкостью:

• cSHAKE: включает явное разделение домена с помощью дополнительно введенной строки
• KMAC: вариант для аутентификации сообщений с использованием хэша с ключом
  
• KMACXOF: версия KMAC XOF с хеш-выходом, который может быть расширен по мере необходимости (согласно SHAKE)
• TupleHash и TupleHashXOF: хешированные кортежи с любым количеством строк, при этом разные кортежи хешируются по-разному, например Б. также («ab», «c») и («a», «bc») и («a», «bc», «»)
• ParallelHash и ParallelHashXOF: предназначены для лучшей поддержки возможностей параллельных вычислений современных процессоров.

Похожие записи:

Кубинское конвертируемое песо (cuc, валюты стран карибского бассейна) → российский рубль, ₽ (rub, основные мировые валюты) Майнинг ravencoin (rvn): настройка, доходность, перспективы Amd radeon ™ rx 570 загрузка драйвера Что, если сатоши накамото внезапно вернётся? Discovered Тест и обзор видеокарты asus radeon rx 570 expedition oc 4gb gddr5