DataV:Criar, visualizar e publicar aplicações de visualização

Senha

1. Na caixa de diálogo Publish, ative a opção Password.

2. No campo Password, insira sua senha de verificação.

   A senha deve ter pelo menos 6 caracteres e atender a todas as três condições abaixo:

   • Incluir pelo menos uma letra maiúscula (A-Z).

   • Incluir pelo menos uma letra minúscula (a-z).

   • Incluir pelo menos um número (0-9).

   Após definir a senha com sucesso, o sistema exibirá Access control is configured.

3. Opcional: configure o Verification Validity Period.

   Importante

   Só é possível configurar o Verification Validity Period após definir uma senha com sucesso ou ativar a verificação por Token.

   • Selecione Verification Validity Period para definir a validade da senha (máximo de 32 horas). Após inserir a senha corretamente e acessar a aplicação pela primeira vez, o visitante poderá acessá-la novamente dentro desse período sem precisar reinseri-la.

   • Desmarque Verification Validity Period para exigir a senha em cada acesso.

   Após a configuração bem-sucedida da senha, os visitantes precisarão inseri-la para acessar o link compartilhado.

Token

Integre as permissões de acesso das aplicações de visualização ao seu sistema de permissões usando a verificação por Token.

Na caixa de diálogo Publish, ative a opção Token para habilitar a verificação por Token. Após ativá-la, execute as seguintes operações:

• Obtenha o código de verificação do Token.

  Ao ativar a opção Token, o DataV gera um Token. Registre-o para uso posterior.

• (Opcional) Configure o Verification Validity Period.

  • Selecione Verification Validity Period para personalizar a validade da verificação por Token (máximo de 32 horas). Após concluir a verificação e acessar a aplicação pela primeira vez, o visitante poderá acessá-la novamente dentro desse período sem nova verificação.

  • Desmarque Verification Validity Period para exigir verificação em cada acesso.

Com a verificação por Token ativa, ao abrir novamente a página de compartilhamento da aplicação, você receberá a mensagem Access Denied, indicando acesso negado. Para abrir a página, conclua as etapas a seguir.

1. Publique a aplicação de visualização e registre o código dela (o último segmento da URL).

2. Concatene o código à hora atual (em milissegundos), separados por | (BARRA VERTICAL).

3. Use HMAC-SHA256 base64 com o Token para criptografar o código de verificação obtido na etapa anterior.

4. Nomeie o tempo e a assinatura criptografada como _datav_time e _datav_signature, respectivamente.

5. Insira-os na querystring da URL em sequência.

   Importante

   Se precisar passar parâmetros via método GET na URL da aplicação, recomendamos usar a verificação de assinatura de parâmetro Token fornecida pelo DataV por motivos de segurança. Para mais informações, consulte Verificação de assinatura de parâmetro Token da página de compartilhamento do DataV.

   Exemplos de código:

   • PHP:

     <?php
       $token = "kBwoX9rFX9v4zbOT0Gjd_wr65DZ****";
       $screenID = "03d1b68faeb09671046d1ef43f58****";
       $time = time()*1000;
       $stringToSign = $screenID.'|'.$time;
       $signature = urlencode(base64_encode(hash_hmac('sha256', $stringToSign, $token, true)));
       $url = "http://datav.aliyuncs.com/share/".$screenID."?_datav_time=".$time."&_datav_signature=".$signature;
     ?>
     <iframe width=100% height=100% src="<?=$url?>"/>

   • Node.js:

     const crypto = require('crypto');
     var token = "Ev97wOUSAtJusc3Vsd9O2ngr_vfV****";
     var screenID ="14c5448c00ecde02b065c231d165****";
     var time = Date.now();
     var stringToSign = screenID +'|'+ time;
     var signature = crypto.createHmac('sha256', token).update(stringToSign).digest().toString('base64');
     var url="http://datav.aliyuncs.com/share/"+ screenID +"?_datav_time="+time+"&_datav_signature="+ encodeURIComponent(signature);

   • Java:

     package com.company;
     import java.security.*;
     import java.util.Date;
     import javax.crypto.*;
     import javax.crypto.spec.SecretKeySpec;
     import org.apache.commons.codec.binary.Base64;
     import java.net.URLEncoder;
     public class TokenTest {
         public static String getSignedUrl(String screenID, String token){
             Date date = new Date();
             Long time = date.getTime();
             String stringToSign = screenID + "|" + time;
             String signature = HMACSHA256(stringToSign.getBytes(), token.getBytes());
             String url = "http://datav.aliyuncs.com/share/"+ screenID +"?_datav_time="+time+"&_datav_signature="+ signature;
             return url;
         }
         /**
          *  Use Java's native digest implementation for SHA256 encryption.
          * @param str The encrypted message.
          * @return
          */
         public static String HMACSHA256(byte[] data, byte[] key)
         {
             try  {
                 SecretKeySpec signingKey = new SecretKeySpec(key, "HmacSHA256");
                 Mac mac = Mac.getInstance("HmacSHA256");
                 mac.init(signingKey);
                 return URLEncoder.encode(byte2Base64(mac.doFinal(data)));
             } catch (NoSuchAlgorithmException e) {
                 e.printStackTrace();
             } catch (InvalidKeyException e) {
                 e.printStackTrace();
             }
             return null;
         }
         private static String byte2Base64(byte[] bytes){
             return Base64.encodeBase64String(bytes);
         }
         public static void main(String[] args) throws Exception {
             System.out.println(getSignedUrl("screenId", "token"));
         }
     }

   • C#:

     using System;
     using System.Security.Cryptography;
     using System.Text.RegularExpressions;
     using System.Collections.Generic;
     using System.Linq;
     using System.Web;
     using System.Text;
     
     namespace datavToken
     {
         class Program
         {
             static void Main(string[] args)
             {
                 var dic = new Dictionary<string, string>();  // Custom parameters.
                 dic.Add("datav_sign_no", "123998");         // datav_sign_ prefix, needs to be signed.
                 dic.Add("datav_sign_lo", "kk");
                 dic.Add("datav_sign_ao", "xx");
     
                 dic.Add("name", "123");   // Does not need to be signed.
                 // Share page prefix, screen share ID, token, custom parameter dictionary.
                 Console.WriteLine(GenerateUrl("https://datav.aliyun.com/share/", "ca74bea5e45503070d607795e0****", "66DsL2qjrXRHluSJScv_flOUhn****", dic));
             }
             private static string GenerateUrl(string datavBase, string screenId, string token, Dictionary<string, string> customeParams)
             {
                 string pattern = @"^datav_sign_.*";
                 string timestamp = GetTimeStamp();
     
                 // Parameter sorting.
                 Dictionary<string, string>.KeyCollection keyCol = customeParams.Keys;
                 List<string> signKeys = new List<string>();
     
                 foreach (var item in keyCol.ToList())
                 {
                     if (Regex.IsMatch(item, pattern))
                     {
                         signKeys.Add(item);
                     }
                 }
     
                 // Sort by key.
                 signKeys = signKeys.OrderBy(k => k).ToList();
     
                 string paramsSignStr = signKeys.Aggregate("", (total, key) =>
                 {
                     if (total != "")
                     {
                         total += "&";
                     }
                     total += key + "=" + customeParams[key];
                     return total;
                 });
                 //No parameter authentication
                 string signStr = screenId + "|" + timestamp;
                 //Parameter authentication exists
                 //string signStr = screenId + "|" + timestamp + "|" + paramsSignStr;
                 
     
                 var encoding = new System.Text.ASCIIEncoding();
                 byte[] keyByte = encoding.GetBytes(token);
                 byte[] messageBytes = encoding.GetBytes(signStr);
                 string signature;
                 using (var hmacsha256 = new HMACSHA256(keyByte))
                 {
                     byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
                     signature = Convert.ToBase64String(hashmessage);
                 }
     
                 var paramDic = new Dictionary<string, string>();
                 paramDic.Add("_datav_time", timestamp);
                 paramDic.Add("_datav_signature", signature);
     
                 foreach (var item in customeParams)
                 {
                     paramDic.Add(item.Key, item.Value);
                 }
                 return datavBase + screenId + "?" + ParseToString(paramDic);
             }
             public static string GetTimeStamp()
             {
                 TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
                 return Convert.ToInt64(ts.TotalMilliseconds).ToString();
             }
             static public string ParseToString(IDictionary<string, string> parameters)
             {
                 IDictionary<string, string> sortedParams = new SortedDictionary<string, string>(parameters);
                 IEnumerator<KeyValuePair<string, string>> dem = sortedParams.GetEnumerator();
     
                 StringBuilder query = new StringBuilder("");
                 while (dem.MoveNext())
                 {
                     string key = dem.Current.Key;
                     string value = dem.Current.Value;
                     if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))
                     {
                         query.Append(key).Append("=").Append(HttpUtility.UrlEncode(value)).Append("&");
                     }
                 }
                 string content = query.ToString().Substring(0, query.Length - 1);
     
                 return content;
             }
         }
     }

Lista de permissões de endereços IP

Ao ativar a lista de permissões de IP, a aplicação publicada só poderá ser acessada por endereços IP incluídos no intervalo especificado.

1. Na caixa de diálogo Publish, ative a Lista de Permissões de IP.

2. No campo IP Address Whitelist abaixo, insira seus endereços IP, separando as entradas por vírgulas.

   Após configurar a lista de permissões com sucesso, qualquer tentativa de acesso ao link compartilhado por um IP não listado resultará em negação de acesso à página da aplicação.