Auto assinando um arquivo .jar

Geralmente, em aplicações standalone no Java, distribuímos arquivos empacotados em JAR. Por questões de segurança, muitos clientes barram a execução arquivos JAR que não estejam assinados. Quando se usa Java Web Start, via JNLP, também o JAR é barrado. Sendo assim, para resolver esse problema, podemos auto-assinar no JAR. Vamos ver como se faz isso:

Empacote o JAR

A primeira coisa a se fazer é compilar e buildar sua aplicação e em formato JAR. Se você usa Ant, Maven, Gradle… Basta buildar usando eles e gerar o JAR. Depois de gerado o JAR, empacote com esse comando:

jar -cf MyAwesomeApp.jar *.*

Criando a KeyStore

Agora vamos criar a KeyStore para poder assinar o JAR.

keytool -genkey -keystore myKeyStore -alias jdc

Assim que você rodar o comando, será perguntado diversas coisas como organização, nome, etc etc etc. Preencha as informações.

Assinando o JAR

E finalmente, assinando o JAR:

jarsigner -keystore myKeyStore MyAwesomeApp.jar jdc

agora você já pode fazer deploy, usar JNLP etc. Mas fique atento que JARs auto-assinados gera um warning na JVM quando vai executa-los.

Fonte →

https://www.ricardogiaviti.com.br/2017/08/como-auto-assinar-um-arquivo-jar/

Codigo Java como gerar uma assinatura digital, para assinar um arquivo.

O objetivo deste artigo e demonstrar como gerar uma assinatura digital, para assinar um arquivo.

Para tanto vamos precisar de um par de chaves um Privada e Outra Publica.

Com a chave Privada assinamos e criptografar-mos o documento, esta chave como o nome diz e privada e não pode ser revelada, para que o destinatário possa abrir o documento e comprovar a autoria do mesmo verificando o mesmo e validando a assinatura enviamos a chave Publica, desse modo poderemos enviar a mesma chave para diversos destinatários, desse modo somente quem possuir a chave publica poderá poderá abrir e validar a assinatura.

Podemos criar uma par de chaves de varias maneiras, pelo shell do linux, sites softwares etc, o JAVA e muito utilizado em aplicações WEB para esses fim, e possui muitas classes para criar chaves encriptografar ler arquivos de diversos formatos, e também possui um tipo de dado para chaves.

Algumas classes utilizadas para criptografia criação de Chaves e validação de assinaturas:

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.PrivateKey;

import java.security.PublicKey;

import javax.crypto.Cipher;

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.Signature;

import java.security.spec.PKCS8EncodedKeySpec;

Para criarmos uma assinatura digital precisamos de uma instância da classe java.security.Signature. Para isso podemos chamar o metodo Signature.getInstance(), com seus devidos parâmetros de algoritimos e Provedor, neste exemplo esta sendo utilizado o algotirimo SHAcithDSA e o provedor SUN.

Antes utilizarmos o objeto Signature para iniciar com a PrivateKey, no exemplo também e demonstrado como se obter a PrivateKey, e iniciaremos a assinatura chamando com o método initSign().

Agora já estamos aptos a gerar uma Assinatura Digital. Dentro do arquivo que pretendemos assinar, para isso temos trabalhar com dados tipo Byte[], usamos o método Files.readALLBytes().

E então para assinar digitalmente o documento, temos que atualizar-lo, isso se fazer com o método update() passamos os bytes para a Signature, e para gerar a assinar no documento fechamos com o método sign() , este método retorna uma array de bytes da assinatura.

Exemplo de Código:

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;

public class GenerateDigitalSignature {
    public static void main(String[] args) {
        try {
            // Get instance and initialize a KeyPairGenerator object.
            KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA", "SUN");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
            keyGen.initialize(1024, random);

            // Get a PrivateKey from the generated key pair.
            KeyPair keyPair = keyGen.generateKeyPair();
            PrivateKey privateKey = keyPair.getPrivate();

            // Get an instance of Signature object and initialize it.
            Signature signature = Signature.getInstance("SHA1withDSA", "SUN");
            signature.initSign(privateKey);

            // Supply the data to be signed to the Signature object
            // using the update() method and generate the digital
            // signature.
            byte[] bytes = Files.readAllBytes(Paths.get("ENDEREÇO DO "));
            signature.update(bytes);
            byte[] digitalSignature = signature.sign();

            // Save digital signature and the public key to a file.
            Files.write(Paths.get("signature"), digitalSignature);
            Files.write(Paths.get("publickey"), keyPair.getPublic().getEncoded());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

O Ryzen 9 3950X

O Ryzen 9 3950X possui 16 núcleos e uma arquitetura baseada em 7nm

Veja também:AMD e Samsung assinam parceria para trazer Radeon aos smartphonesComo o atraso da Intel reacendeu a briga com a AMD após anosNovo chip da AMD iguala desempenho de um Core i9 pela metade do preço

Durante o evento Next Horizon Gaming da AMD, a empresa apresentou sua nova leva de peças de hardware que, no papel, parece ser capaz de se tornar os hardwares mais poderosos que temos no mercado. Eles anunciaram sua terceira geração de processadores Ryzen e um deles parece bem impressionante.

O grande destaque ficou para o processador Ryzen 9 3950X, que traz 16 núcleos, e custa US$750 (aproximadamente R$2893). Além do generoso número de cores, o processador possui um clock de 3.5GHz, um cache de 72MB e um TDP (Projeto de Força Térmica) de 105W, considerado algo inédito no mercado.


O grande destaque desse processador é sua arquitetura baseada em 7nm e que conta com soquetes tamanho padrão, que se encaixam na maioria das placas mãe AM4 disponíveis no mercado. De acordo a AMD, esses 7nm não são apenas mais econômicos e eficientes, mas mais rápidos nas tarefas por conta de seus núcleos adicionais e apresentam melhor desemprenho em jogos.

A AMD disse também que planeja continuar oferecendo compatibilidade de entrada de placas de vídeo até 2020. Essa resolução da empresa é para evitar que os consumidores comprem uma nova placa juntamente das peças usadas para a atualização de sua CPU. “Será preciso um grande ponto de inflexão na tecnologia para sairmos do soquete AM4”, diz David McAfee, da AMD, acrescentando que, provavelmente, será necessária uma grande mudança na arquitetura da placa mãe antes da AMD se preocupar em atualizar sua conexão.

Um dos focos desse equipamento está voltado para os streamers. O processador permite que esses criadores de conteúdo consigam transmitir em alta qualidade, sem perda de desempenho ou a queda de quadros que geralmente acontece durante essas transmissões.


A AMD está bastante confiante de que vai conseguir adquirir uma parte do mercado que a arquirrival Intel, outra fabricante de processadores, não consegue alcançar, já que eles mal conseguem chegar a processadores de 10nm. Travis Kirsch, da AMD, afirmou: “não acho que há alguma razão para as pessoas comprarem processadores da Intel após fazermos isso”. Em sua fala, ele se refere ao que os novos processadores podem oferecer em relação ao seu concorrente.

Construindo um GRidView em Gambas3.

Controlando o GridView.

O controle do GridView, funciona como outros controles da caixa de ferramentas, e herda seus atributos a partir da Classe de Controle, o GridView implementa um controle que exibe os dados dentro do GridView. Essa classe é criada, O padrão da Syntaxe da linguagem Gambas para o GridView é:

DIM hGridView AS GridView

hGridView = NEW GridView ( Parent AS Container )

O código acima criará um novo GridView,

Esta Classe age como um array somente de leitura.

Para ter acesso aos dados de uma célula desejada e preciso declarar da seguinte maneira:

Declarar uma GridCell variável que poderá ser obtida GridView array (the GridCell is a virtual class): Para isso decflaramos duas variáveis: uma para o GridView e outra para o GridCell.

DIM hGridView AS GridView

DIM hGridCell AS .GridCell

Agora referimos a célula indexada por dois parâmetros inteiros.

hGridCell = hGridView [ Row AS Integer, Column AS Integer ]

Primeiro declaramos o GriudView depois a célula, e então obtemos o valor da célula desejada, indexando com indexes da linha e coluna respectivamente.

Criaremos um exemplo:

Nese caso vamos criar um GridView com quatro linhas e três colunas, e vamos popular as trẽs primeiras linhas com texto e a última linha com figura

Vamos acessar a ultima linha com texto para demonstrar com o acesso aos dados funciona, nosso programa terá três botões Quit, Clear e Reset

O botão quit irá fechar o programa.

O botão Clear invocara o método GridView.Clear para limpar o conteúdo da Grid

O botão reset irá recompor o Grig com os dados originais

Agora vamos começas a digiar o código. Dê um duplo click no form.

' Gambas class file

PUBLIC SUB Form_Open()

Form1.Caption = " GridView Example "

END

Quando o programa começa se existir um construtor ele será executado primeiro.

Nosso constutor irá carregar nossos três ícones e popular o grid.

Primeiro e preciso declarar a três variáveis globais para as figuras como segue:

PUBLIC SUB _new()

DIM hPic1 AS Picture

DIM hPic2 AS Picture

DIM hPic3 AS Picture

Agora vamos instanciar nossa figura como um objeto.

hPic1 = NEW Picture

hPic2 = NEW Picture

hPic3 = NEW Picture

Agora carregando as figuras para os objetos.

hPic1.Load("GridPic.png")

hPic2.Load("GridPic2.png")

hPic3.Load("GridPic1.png")

Agora podemos definir as configurações do grid, numero de linhas numero de colunas e seu tamanho;

Definindo numero de linhas e colunas respectivamente:

GridView1.Columns.Count = 3

GridView1.Rows.Count = 4

Para configurar o tamanho das celulas precisamos definir duas coisas a largura das colunas e a altura das linhas, como segue:

GridView1.Columns.Width = 72

GridView1.Rows.Height = 36

Tudo declarado instanciado, carregado , definido o numero de linhas e colunas e suas dimensões

Agora vamos carregar cada celula com um valor:

GridView1[0,0].Text = "0,10"

GridView1[0,1].Text = "0,11"

GridView1[0,2].Text = "0,25"

GridView1[1,0].Text = "1,90"

GridView1[1,1].Text = "1,109"

GridView1[1,2].Text = "2.99"

Também podemos fazer a carga alinhando o conteúdo dentro das células, como segue.

GridView1[2,0].Alignment = Align.Center

GridView1[2,1].Alignment = Align.BottomLeft

GridView1[2,2].Alignment = Align.TopRight

Primeiro definimos o alinhamento e agora podemos atribuir o conteúdo de cada célula.

GridView1[2,0].Text = "2,0"

GridView1[2,1].Text = "2,1"

GridView1[2,2].Text = "1,2"

Finamente podemos carregar as imagens para as céulas do grida

GridView1[3,0].Picture = hPic1

GridView1[3,1].Picture = hPic2

GridView1[3,2].Picture = hPic3

END

Vamos acrescentar três botões de Controle, Limpar , Ressetar Fechar

PUBLIC SUB Button1_Click()

ME.Close

END

PUBLIC SUB Button2_Click()

GridView1.Clear

END

_new

END

Pronto agora e compilar e rodar o programa para ver como funciona.

VEJA O VÍDEO ABAIXO.