Les petites funcions sempre cal tenir-les a mà. Es fan servir un cop, i un altra, i un altra... Aquesta és una d'aquelles funcions que sempre estem repetint.

Donat un string com per exemple: "Lorem ipsum dolor sit amet, 'consectetur' adipisici elit". Es vol obtenir "consectetur", es a dir el text que està entre els '. Per això es pot fer:

string Text = "Lorem ipsum dolor sit amet, 'consectetur' adipisici elit";
string Resultat = SubString(Text, "'", "'");
//Resultat = consectetur

public string SubString(string OnBusquem, string CaracterInicial, string CaracterFinal)
{
	int Inici = OnBusquem.IndexOf(CaracterInicial) + CaracterInicial.Length;
	int Fi = OnBusquem.IndexOf(CaracterFinal, Inici);
	return OnBusquem.Substring(Inici, Fi - Inici);
}

També es pot fer d'una altra manera amb el mateix resultat:

string Text = "Lorem ipsum dolor sit amet, 'consectetur' adipisici elit";
string Resultat = SubString(Text, "'", "'");

public string SubString(string OnBusquem, string CaracterInicial, string CaracterFinal)
{
	return OnBusquem.Split(new char[] { CaracterInicial[0], CaracterFinal[0] })[1];
}

Quina és millor? Quina s'entén millor? Per gustos els colors. Encara que a mi m'agrada més la primer opció ja que té algo més de flexibilitat. Per exemple, imaginem que enlloc que el separador sigui un caràcter, que sigui varis. Com quan volem extreure un valor de dins d'un string XML (sense muntar l'objecte XML), quedaria algo com:

string Buscar = "dasjdhasdjkah<abcd>Lorem ipsum</abcd>dsadadadsadasds";
string resultat = SubString(Buscar, "<abcd>", "</abcd>");
//Resultat = Lorem ipsum

Respecte el post dels strings hexadecimals, tenir més d'una forma de fer el mateix és enriquidor, així no tot semblen claus.

If all you have is a hammer, everything looks like a nail

Per validar que un string té una pinta com "0F4D3398FFDD", és a dir és un string Hexadecimal. Es pot fer una funció com:

public bool OnlyHexInString(string test)
{
    // For C-style hex notation (0xFF) you can use @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z"
    return System.Text.RegularExpressions.Regex.IsMatch(test, @"\A\b[0-9a-fA-F]+\b\Z");
}

Fer servir una expressió regular està molt bé, però ho trobo una mica excessiu ja que no cal tanta potència per fer algo senzill. Penso que és millor fer:

private bool IsHex(IEnumerable<char> chars)
{
	bool isHex;
	foreach (var c in chars)
	{
		isHex = ((c >= '0' && c <= '9') ||
				 (c >= 'a' && c <= 'f') ||
				 (c >= 'A' && c <= 'F'));

		if (!isHex)
			return false;
	}
	return true;
}

Si es vol tenir una sobredosi d'herois "Made in USA" aquesta és la peli. Surten tots. Inclús "Hulk". El més interessant és que és consistent amb les altres pelis a nivell de guió i a nivell d'actors (a cada heroi l'interpreta l'actor que ho feia a la peli original).

Per a nens d'onze anys o més perfecte, un malo malote (el Loki, germà de Thor), i un munt de bons. A vegades fa una mica de pena que només hi hagi un malote i un munt de bons. Obviament amb tants bons el resultat és l'esperat. Bons efectes que desafien la física i castanyes a tutiplen, i llestos!

Aquest cap de setmana passat he vist aquesta peli. Directament és absurda, però espectacular. I no absurda en que existeix un bitxo tamany Godzilla, si no absurda en quan a idees que tenen per matar a uns bitxos més dolents, els Mutas, que s'alimenten de radiació. Destacar que apareix el protagonista de Breaking Bad en un paper secundari. Finalment en Godzilla que és un "buenazo" després de destruir mitja ciutat (clar és que construeixen els edificis apretats i ell pobret no passa i es sent que té el seu espai personal envaït), doncs això, que al final és ell el que s'ha d'encarregar del tema dels Mutas.

Per adolescents de 11 anys, que els agraden les pelis d'acció, és ideal. Si agraden els efectes especials i la lluita de coses "grosses" a càmera lenta també perfecte. Per la resta no tant.

La continuació de l'anterior, però aquesta ja passa en l'edat "actual" i el "capitan America" és un agent de "S.H.I.E.L.D", com la "T.I.A." de Mortadelo i Filemón però en guay i millor.

Resulta que Hydra no va desaparèixer del tot i cal acabar de liquidar el tema. A més a més hi ha un dolent molt "maloso" que és el "soldat d'hivern" amb poders similar al "capitan". Però en realitat no és tan dolent, només ho són els seus jefes. En aquesta hi ha una mica més d'enbolic.

Jo gairebé tinc una sobredosi, però com sempre, bons efectes, bons actors, guió txepi-txepi, i pel tram d'edat al que va dirigida és ideal.

Si us agrada el tema de superherois Marvel aquesta peli us agradarà. I a més a més tal com indica el nom és "made in USA", sense complexes, amb tots els tòpics i bons efectes especials.

Tracta d'un noi, molt bo, molt bo, molt bo, molt patriòtic, però esquifit, al que un científic renegat alemany li injecta un medicament que el transforma en un supercachas. I aleshores es pot dedicar a donar canya als dolents. Els dolents no són només els nazis, són una organització secreta que es diu Hydra, on el seu lider (és l'agente Smith de Matrix) ha aconseguit fer una font d'energia superpoderosa d'un trasto mitològic noruec. I aoa, a machacar als pobres soldats d'Hydra.

Recomanable? Ha d'agradar el tema Marvel, i és previsible, però per segons quins trams d'edat és com el Equipo A però XL. I això ja depèn del gust de cadascú.

Aquesta pel·lícula és fruit d'una fórmula matemàtica: Robocop + Cortocircuito = Chappie.

Tracta d'un informàtic que treballa programant robots policia. I fa un que té una intel·ligència artificial que el fa capaç de raonar. Però amb tan mala sort que uns "dolents" li roben el robot (en Chappie). Comença com un nen petit i va evolucionant, aprenent coses dolentes dels "dolents", que francament són massa bons. Un company de feina del programador ha inventat un robot competidor, molt similar al robot dolent de Robocop, i ja la tenim liada.

La peli es deixa veure, bons efectes, guió algo fluix i un final pse, pse (encara que acaba bé), ah! I no passa als USA! Jo com tinc debilitat pels robotets la recomano, algu altra que no sigui del ram, potser vol anar a veure una altra cosa.

He tingut que implementar la firma MAC ANSI X9.19 (MAC = Message Authentication Code) i com tots els temes de seguretat és curiós la poca informació que hi ha.

Una firma (MAC) d'aquest tipus serveix per verificar que un missatge no ha estat manipulat i ens arriba tal com es va enviar. Si hi ha un error a la xarxa es detectarà, o si un "algú" dolent modifica el missatge no podrà regenerar la firma per que no coneix la clau a partir de la que es genera la MAC. El receptor com sí té aquesta clau pot verificar el contingut del missatge.

Aquesta firma MAC ANSI X9.19 és un estàndard bancari "made in USA". És una evolució del X9.9 i també es coneix com a Retail-MAC. És un xifrat dels anomenats DES-CBC, on DES vol dir "Data Encryption Standard" i CBC és el "Cipher Block Chaining". Existeix una norma internacional semblant, una mica més permissiva, la ISO 9807 ja que permet fer servir altres algoritmes de xifrat. Diguem que la ANSI X9.19 és una possible implementació de la ISO 9797 quan la mida del bloc a xifrar és de 64 bits, la longitud de la MAC 32 i es fa servir el DES com algoritme de xifrat.

El DES es un algoritme de xifrat ja força antic que fa servir claus de 56 bits però amb la X9.19 també s'aplica un xifrat extra en l'últim pas fent servir una clau de 128bits com si fos un 3DES normal. Els passos a seguir són els següents:

1. Al missatge d'entrada s'ha de posar padding (relleno). En aquest cas com no cal treure'l posteriorment es posen els bytes a 00 que facin falta fins que la longitud del missatge és múltiple de 8 bytes.
2. Es divideix la clau de 128bits en dues sub-claus de 64, la part esquerra s'anomena K, la part dreta K'.
3. Es divideix el missatge en blocs de 8 bytes.
4. Es xifra amb DES el primer bloc amb la clau K.
5. Al resultat es fa una XOR byte a byte amb el següent bloc (és el CBC).
6. Es xifra el resultat de la XOR amb la clau K. Si NO és l'últim bloc tornem al pas anterior.
   Si és l'últim bloc anem al pas següent.
7. Aquest últim resultat es desxifra amb la clau K'. Òbviament encara que sigui un desxifrat no s'obté res coherent.
8. Es xifra altra cop amb la clau K. És com si fos un 3DES en aquest últim pas. El resultat és la MAC.

Però millor una imatge:

He fet dues implementacions en C#, una fent les coses manuals i l'altra amb llibreries de sistema, ambdues ofereixen el mateix resultat. Al codi hi ha un exemple que he trobat amb els valors calculats.

public byte[] SubArray(byte[] data, int index, int length)
{
    byte[] result = new byte[length];
    Array.Copy(data, index, result, 0, length);
    return result;
}

private void btnFirma_Click(object sender, EventArgs e)
{
    try
    {

	if (!ValidarClau()) return;

	NetejaTXTs();

	byte[] IV = new byte[8]; //empty byte array
	byte[] key = ConvertHexStringToByteArray(txtKey.Text);
	byte[] LeftKey = SubArray(key, 0, 8);
	byte[] RightKey = SubArray(key, 8, 8);
	byte[] data;

	if (chkHexString.Checked)
	{
	    data = ConvertHexStringToByteArray(Neteja(txtOriginal.Text));
	}
	else
	{
	    data = Encoding.ASCII.GetBytes(Neteja(txtOriginal.Text));
	}
	//Exemple
	//Dades = 4E6F77206973207468652074696D6520666F7220616C6C20
	//Clau = 0123456789ABCDEFFEDCBA9876543210
	//Firma = A1C72E74EA3FA9B6

	DES DESalg = DES.Create();
	DESalg.Mode = CipherMode.CBC;
	DESalg.Padding = PaddingMode.None;
	ICryptoTransform SimpleDES_Encriptador = DESalg.CreateEncryptor(LeftKey, IV);
	ICryptoTransform SimpleDES_Desencriptador = DESalg.CreateDecryptor(RightKey, IV);

	byte[] result = new byte[8];
	byte[] datablock = new byte[8];
	int remain = data.Length % 8;
	int LoopCount = data.Length / 8;

	/*
	//Padding a 0
	if (remain != 0)
	{
	    int extra = 8 - (data.Length % 8);
	    int newLength = data.Length + extra;
	    byte[] newData = new byte[newLength];
	
	    Array.Copy(data, newData, data.Length);
	    data = newData;
	}
	result = SimpleDES_Encriptador.TransformFinalBlock(data, 0, data.Length);

	byte[] block = new byte[8];
	
	// Agafem l'ultim block
	Array.Copy(result, result.Length - 8, block, 0, 8);

	// Desencriptar l'ultim bloc a la K'
	block = SimpleDES_Desencriptador.TransformFinalBlock(block, 0, 8);

	// Encriptar altra cop el resultat amb K
	block = SimpleDES_Encriptador.TransformFinalBlock(block, 0, 8);

	result = block;
	*/

	//Si el que s'ha de firmar és multiple de 8...
	if (remain == 0)
	{
	    LoopCount--;
	    remain = 8;
	}

	//Primer block
	Array.Copy(data, 0, datablock, 0, 8);
	result = EncryptBlock(SimpleDES_Encriptador, datablock);

	for (int i = 1; i < LoopCount; i++)
	{
	    datablock = new byte[8];
	    Array.Copy(data, i * 8, datablock, 0, 8);
	    //Això fa el CBC
	    datablock = XorArray(datablock, result);
	    result = EncryptBlock(SimpleDES_Encriptador, datablock);
	}

	//Ultim block
	byte[] LastBlock = new byte[8];

	//Això fa padding a zeros
	Array.Copy(data, data.Length - remain, LastBlock, 0, remain);
	LastBlock = XorArray(LastBlock, result);

	result = EncryptBlock(SimpleDES_Encriptador, LastBlock);

	result = EncryptBlock(SimpleDES_Desencriptador, result);

	result = EncryptBlock(SimpleDES_Encriptador, result);

	if (!chkHexString.Checked) txtBase64.Text = ConvertByteArrayToHexString(data);
	txtEncrypted.Text = ConvertByteArrayToHexString(result);
	   
    }
    catch(Exception E)
    {
	MessageBox.Show(E.Message);
    }
}

public byte[] XorArray(byte[] buffer1, byte[] buffer2)
{
    for (int i = 0; i < buffer1.Length; i++)
	buffer1[i] ^= buffer2[i];
    return buffer1;
}

private byte[] EncryptBlock(ICryptoTransform crypt, byte[] toEncrypt)
{
    try
    {
	MemoryStream mStream = new MemoryStream();

	CryptoStream cStream = new CryptoStream(mStream,
	    crypt,
	    CryptoStreamMode.Write);
	cStream.Write(toEncrypt, 0, toEncrypt.Length);
	cStream.FlushFinalBlock();
	byte[] ret = mStream.ToArray();
	cStream.Close();
	mStream.Close();

	Console.WriteLine("DES OUTPUT : " + ConvertByteArrayToHexString(ret));
	return ret;
    }

    catch (CryptographicException e)
    {
	Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
	return null;
    }
}

Igual que els corbs no poden resistir-se a objectes brillants, hi ha hardware que és: "oh! shiny!". Joguines brillants... A mi em passa amb els dissipadors, Noctua m'agraden. Són tan "cucos", em posaria uns quants.

Ara Noctua ha tret un nou model per HTPC, el NH-L9x65. Jo tinc un HTPC, que francament no fa gens soroll i porta anys amb els seu dissipador, però aquest és temptador... Encara no el tinc però en el següent muntatge a veure si cau. El que m'agrada força és el sistema d'ancoratge a la placa base. Enlloc de ser les típiques pues de plàstic té una placa metàl·lica per sota que proporciona una subjecció molt estable, i unes molles donen la pressió exacte sobre el processador.