Kriptografide **RC5**, basitliği ile dikkat çeken **simetrik - anahtar blok şifresidir**. 1994 yılında Ronald Rivest tarafından tasarlanmıştır. RC, "Rivest Cipher" veya bir başka seçenek olarak "Ron's Code" anlamına gelmektedir (RC2 ve RC4'ü karşılaştırın). Gelişmiş Şifreleme Standardı(AES) adayı RC6 ve RC5 blok şifrelerine dayanıyordu.

Tanım
-----

Birden fazla şemadan farklı olarak **RC5**, değişken bir **blok boyutuna** (32,64 veya 128 bit olur), **anahtar boyutuna** (0 ila 2040 bit arası) ve tur sayısına (0 ile 255 arası)sahiptir. Genel olarak önerilen parametre seçimi; 64 bit blok boyutu, 125 bit bir anahtar boyutu ve 12 tur sayısına sahip olması gerekir.RC5 blok şifrelemenin önemli bir özelliği de, veriye bağlı rotasyonların kullanılmasıdır. RC5'in hedeflerinden biri ise, bu tur işlemlerin bir **kriptografik ilkel** olarak çalışmasını ve değerlendirmesini sağlamaktır. Bundan ayrı RC5, bir dizi **modüler** eklemeden ve **özel VEYA (XOR)'**lardan oluşmaktadır. Algoritmanın genel yapısı **Feitsel** benzeri bir ağdır. Şifreleme ve şifre çözme yöntemleri birkaç kod satırında belirtilebilir. Veriye bağlı rotasyonların yeniliği ile beraber göz alıcı basitliği olan RC5'i kriptoanalistler için ilgi çekici bir çalışma nesnesi haline getirildi.RC5 genel olarak;

RC5-w/r/b şeklinde ifade edilir. w:Bit cinsinden sözcük boyutu, r:Tur sayısı, b: Anahtardaki 8 bitlik byte sayısı.

Özellikleri
-----------

* Yazılımsaldır.
* **S-box** bulunmaz.
* Basit, esnek ve hızlıdır.
* **XOR** işlemi vardır.
* Güvenilirliği yüksektir.
* Kırılma olasılığı düşüktür.

Algoritma
---------

RC5 şifreleme ve şifre çözme, rastgele anahtarı, şifreleme ve şifre çözme işlemleri sırasında sırayla (ve yalnızca bir kez) kullanılacak 2(r+1) kelimeye genişletir. Aşağıdakilerin tümü, Rivest'in RC5 hakkındaki gözden geçirilmiş makalesinden alınmıştır.

### Anahtar Genişletme

Anahtar genişletme algoritması, önce sözde kodda, ardından doğrudan referans belgesinin ekinden kopyalanan örnek C kodunda aşağıda gösterilmiştir.

Makalenin adlandırma şemasına göre aşağıdaki değişken adları kullanılır:

w - Bir kelimenin bit cinsinden uzunluğu, tipik olarak 16, 32 veya 64. Şifreleme 2 kelimelik bloklarda yapılır.

u = w/8 - Bir kelimenin bayt cinsinden uzunluğu.

b - Anahtarın bayt cinsinden uzunluğu.

K[] - Bir bayt dizisi olarak kabul edilen anahtar (0 tabanlı indeksleme kullanılarak).

c - Sözcüklerdeki anahtarın uzunluğu (veya b = 0 ise 1).

L[] - Anahtar zamanlaması sırasında kullanılan geçici bir çalışma dizisi. kelimelerdeki anahtara başlatıldı.

r - Verileri şifrelerken kullanılacak tur sayısı.

t = 2(r+1) - gerekli yuvarlak alt anahtarların sayısı.

S[] - Yuvarlak alt anahtar sözcükler.

P w - Olarak tanımlanan ilk sihirli sabit Odd((e-2)\*2^{w})}Odd((e-2)\*2^{w}), burada Odd verilen girdiye en yakın tek tam sayıdır, e  18 Mart 2022 tarihinde Wayback Machine sitesinde arşivlendi. doğal logaritmanın tabanıdır ve w yukarıda tanımlanmıştır. w'nin ortak değerleri için, P w'nin ilişkili değerleri burada onaltılık olarak verilmiştir:

w = 16 için : 0xB7E1

w = 32 için : 0xB7E15163

w = 64 için : 0xB7E151628AED2A6B

Q w - Olarak tanımlanan ikinci sihirli sabit {{\displaystyle Odd((\phi -1)\*2^{w})}Odd((\phi - 1) \* 2^w), burada Odd verilen girişe en yakın tek tam sayıdır, burada {{\displaystyle \phi altın  20 Mart 2022 tarihinde Wayback Machine sitesinde arşivlendi. orandır ve w yukarıda tanımlanmıştır. w'nin ortak değerleri için, Q w'nin ilişkili değerleri burada onaltılık olarak verilmiştir:

w = 16 için : 0x9E37

w = 32 için : 0x9E3779B9

w = 64 için : 0x9E3779B97F4A7C15

```
  # K'yı kelimelere ayırın.
```

```
# u = w / 8
```

```
c = ceiling(max(b, 1) / u)
```

```
#L başlangıçta 0'a kadar 0 değerli w-uzunluklu kelimelerin c-uzunluklu bir listesidir.
```

```
 for i = b-1 down to 0 do:
```

```
L[i / u] = (L[i / u] <<< 8) + K[i]
```

```
#Anahtardan bağımsız sözde rastgele S dizisini başlat.
```

```
# S başlangıçta =2(r+1) uzunluğunda tanımsız w-uzunluklu kelimelerin listesidir.
```

```
S[0] = P_w
```

```
S[i] = S[i - 1] + Q_w
```

```
for i = 1 to t-1 do:
```

```
# Anahtar zamanlama döngüsü
```

```
i = j = 0
```

```
 A = B = 0,
```

```
do 3 * max(t, c) times:
```

```
A = S[i] = (S[i] + A + B) <<< 3
   B = L[j] = (L[j] + A + B) <<< (A + B)
   i = (i + 1) % t
   j = (j + 1) % c
```

```
return S
```

Örnek kaynak kodu, Rivest'in RC5 hakkındaki makalesinin ekinden sağlanmıştır. Uygulama w:32, r:12 ve b:16 ile çalışılmak üzere tasarlanmıştır.

```
  void RC5_SETUP(unsigned char *K){
```

```
// w = 32, r = 12, b = 16
  // c = max(1, ceil(8 * b/w))
  // t = 2 * (r+1)
  WORD i, j, k, u = w/8, A, B, L[c];
  
  for (i = b-1, L[c-1] = 0; i != -1; i--)
     L[i/u] = (L[i/u] << 8) + K[i];
  
  for (S[0] = P, i = 1; i < t; i++)
     S[i] = S[i-1] + Q;
  
  for (A = B = i = j = k = 0; k < 3 * t; k++, i = (i+1) % t, j = (j+1) % c)
  {
     A = S[i] = ROTL(S[i] + (A + B), 3);
     B = L[j] = ROTL(L[j] + (A + B), (A + B));
  }
```

}

### Şifreleme

Şifreleme, basit bir işlevin birkaç turunu içeriyordu. Güvenlik gereksinimlerine ve zaman hususlarına bağlı olarak 12 veya 20 tur öneriliyor gibi görünüyor. Yukarıda kullanılan değişkenlerin ötesinde, bu algoritmada aşağıdaki değişkenler kullanılır:

**\*** A, B - Şifrelenecek düz metin bloğunu oluşturacak iki kelime.

```
   A = A + S[0]
   B = B + S[1]
```

```
for i = 1 to r do:
```

```
   A = ((A ^ B) <<< B) + S[2 * i]
   B = ((B ^ A) <<< A) + S[2 * i + 1]
```

```
#Şifreli metin bloğu, sırayla A ve B'den oluşan iki kelimelik geniş bloktan oluşur.
```

```
return A, B
```

Rivest'in verdiği örnek C kodu:

```
  void RC5_ENCRYPT(WORD *pt, WORD *ct){
```

```
WORD i, A = pt[0] + S[0], B = pt[1] + S[1];
  
  for (i = 1; i <= r; i++)
  {
     A = ROTL(A ^ B, B) + S[2*i];
     B = ROTL(B ^ A, A) + S[2*i + 1];
  }
  ct[0] = A; ct[1] = B;
```

```
}
```

### Şifre Çözme

Şifre çözme, şifreleme işleminin oldukça basit bir şekilde tersine çevrilmesidir. Aşağıdaki sözde kod işlemi gösterir.

```
   for i = r down to 1 do:
```

```
B = ((B - S[2 * i + 1]) >>> A) ^ A
   A = ((A - S[2 * i]) >>> B) ^ B
```

```
B = B - S[1]
```

```
A = A - S[0]
```

```
return A, B
```

Rivest'in verdiği örnek C kodu:

```
 void RC5_DECRYPT(WORD *ct, WORD *pt){
```

```
WORD i, B=ct[1], A=ct[0];
  
  for (i = r; i > 0; i--)
  {
     B = ROTR(B - S[2*i + 1], A) ^ A;
     A = ROTR(A - S[2*i], B) ^ B;
  }
  
  pt[1] = B - S[1]; pt[0] = A - S[0];
```

```
}
```

Kriptoanaliz
------------

12 turlu RC5 (64 bit bloklu), 244 seçilmiş düz metin kullanan  12 Mart 2022 tarihinde Wayback Machine sitesinde arşivlendi. farklı saldırıya açıktır. 18-20 mermi yeterli koruma olarak önerilmektedir.

Bu zorlu sorunların bir kısmı Distributed.net tarafından organize edilen dağıtılmış bilgi işlem kullanılarak çözülmüştür. Distributed.net, 56-bit ve 64-bit anahtarlarla şifrelenmiş brute- force RC5 mesajlarına sahiptir ve 3 Kasım 2002'den beri 72-bit bir anahtarı kırmak için çalışmaktadır. 6 Ağustos 2021 itibarıyla, %7.900'ü keyspace arandı ve o gün kaydedilen orana göre keyspace'in %100'ünün tamamlanması 127 yıl alacaktı. Görev, küme hesaplama alanında birçok yeni ve özgün gelişmeye ilham verdi.

Algoritma üzerinde bir patente sahip olan RSA Security, RC5 ile şifrelenmiş şifreli metinleri kırmak için bir dizi 10.000 ABD Doları ödül teklif etti, ancak bu yarışmalar Mayıs 2007'den itibaren durduruldu. Sonuç olarak, dağıtılmış.net karar verdi. para ödülünü finanse etmek için. Kazanan anahtarı bulan kişi 1.000 ABD Doları, ekibi (varsa) 1.000 ABD Doları ve Özgür Yazılım Vakfı 2.000 ABD Doları alacaktır.

Kaynakça
--------

1. ↑  Alex Biryukov & Eyal Kushilevitz (1998), "Improved Cryptanalysis of RC5", *EUROCRYPT 1998*, Lecture Notes in Computer Science, Springer, **1403**, ss. 85-99, doi:10.1007/BFb0054119
2. ↑  "Rivest, R. L. (1994).Proceedings of the Second International Workshop on Fast Software Encryption (FSE)" (PDF). 21 Eylül 2018 tarihinde kaynağından arşivlendi (PDF). Erişim tarihi: 20 Mart 2022.
3. ↑  "Rivest RC5" (PDF). 21 Eylül 2018 tarihinde kaynağından arşivlendi (PDF). Erişim tarihi: 20 Mart 2022.
4. ↑  "Biryukov A. and Kushilevitz E. (1998). Improved Cryptanalysis of RC5. EUROCRYPT 1998". 20 Mart 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Mart 2022.
5. 1 2  "www.distributed.net. Retrieved 14 December 2019". 9 Mart 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Mart 2022.
6. ↑  "RC5-72 / Overall Project Stats". 20 Mart 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Mart 2022.
7. ↑  "Archived from. Retrieved". 28 Ekim 2014 tarihinde kaynağından arşivlendi. Erişim tarihi: 28 Ekim 2014.
8. ↑  "Rivest, R. L, "Block Encryption Algorithm With Data Dependent Rotation", U.S. Patent 5,724,428, issued on 3 March 1998." 21 Ocak 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Mart 2022.
9. ↑  "Retrieved 15 December 2019". 22 Ocak 2022 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Mart 2022.