Masque de caractère des données de sortie sur une sélection de

Je suis à l'aide de SQL Server 2008.

Je tiens à caractère masque les données de sortie d'une requête.

C'est mes données à partir d'une colonne sur une table lors d'un select:

column1

384844033434

743423547878

111224678885

Je voudrais une sortie comme celle-ci:

column1

384xxxxxx434

743xxxxxx878

111xxxxxx885

Comment puis-je faire cela?

On dirait que vous parlez à propos de caractère de masquage plutôt que de chiffrement
oui, c'est le caractère de masquage

OriginalL'auteur pyram | 2012-12-12

7

Que vous auriez à utiliser une vue, et de refuser à tous les utilisateurs, SÉLECTIONNEZ l'accès à la table sous-jacente.

Votre point de vue ressemblerait à quelque chose comme
```
SELECT 
     SUBSTRING(x.SecurityNumber,1,3) + 
     'xxxxx' + 
     SUBSTRING(x.SecurityNumber,LEN(x.SecurityNumber) - 2, LEN(x.SecurityNumber))
     AS column1
FROM underlyingTable x
```
Vous pouvez accorder à vos utilisateurs de SÉLECTIONNER l'accès à tout ce point de vue et ont le masqués comme vous l'avez décrit.

Si vous vouliez que votre logiciel client pour être en mesure d'insérer ou de mettre à jour les données dans ce tableau, vous pouvez utiliser l'un PLUTÔT que DE l'INSÉRER ou à la PLACE DU déclencheur de mise à JOUR pour mettre à jour la table de base.

Merci et merci à vous tous pour les réponses!
Je suis à l'aide de l'utilitaire sqlcmd pour SQL Server 2008 et a constaté que les décalages sont différents. Pour la sortie correcte, j'ai utilisé SUBSTRING(x.SecurityNumber,1,3) + 'xxxxx' + SUBSTRING(x.SecurityNumber,LEN(x.SecurityNumber) - 2, LEN(x.SecurityNumber))
Merci @David. Modifiés en conséquence.

OriginalL'auteur Dave Markle

Si vous connaissez la durée de votre champ de données, vous pouvez utiliser la version statique que l'autre réponse, mais vous pouvez toujours créer une fonction pour générer ce:

CREATE FUNCTION MixUpCharacters
(
    @OrigVal varchar(max)
)
RETURNS varchar(max)
AS
BEGIN

DECLARE @NewVal varchar(max)
DECLARE @OrigLen int
DECLARE @LoopCt int
DECLARE @Part varchar(max) = ''
Declare @PartLength int

SET @NewVal = ''
SET @OrigLen = DATALENGTH(@OrigVal)
SET @LoopCt = 1

SET @Part = SUBSTRING(@OrigVal, 4, len(@OrigVal)-6)
set @PartLength = LEN(@Part)

WHILE @LoopCt <= @PartLength
    BEGIN
        -- Current length of possible characters
        SET @NewVal = @NewVal + 'X'

        -- Advance the loop
        SET @LoopCt = @LoopCt + 1
    END

    Return REPLACE(@OrigVal, @Part, @NewVal)
END

Pour cette fonction, vous passerez dans les valeurs que vous souhaitez masquer. Si votre requête serait:

declare @temp table
(
    col1 varchar(50)
)

insert into @temp
values ('384844033434'), ('743423547878'), ('111224678885')

select dbo.MixUpCharacters(col1) col1
from @temp

Voir SQL jouer avec la Démo

Le résultat serait:

|         COL1 |
----------------
| 384XXXXXX434 |
| 743XXXXXX878 |
| 111XXXXXX885 |

Ou ici est une façon de le faire avec une expression de table commune récursive:

;with data(col1) as
(
    select '384844033434'
    union all
    select '7434235878'
    union all
    select '111224678885'
),
s1 (col1,  repfull) as
(
    select col1, 
        SUBSTRING(col1, 4, len(col1)-6) repfull
    from data
),
s2 (col1, item, repfull, r) as
(
    select col1,
        cast('x' as varchar(max)),
        right(repfull, LEN(repfull)-1),
        repfull
    from s1
    union all
    select col1,  
        'x'+ cast(item as varchar(max)),
        right(repfull, LEN(repfull)-1),
        r
    from s2
    where len(repfull) >0
)
select REPLACE(col1, r, item) newValue
from
(
    select col1, item, R,
        ROW_NUMBER() over(partition by col1 order by len(item) desc) rn
    from s2
) src
where rn = 1

Voir SQL jouer avec la Démo

OriginalL'auteur Taryn

2

De SQL Server 2016+ vous pouvez utiliser Dynamique De Données De Masquage fonctionnalité.

Dynamique masquage des données des limites des données sensibles de l'exposition par masquage pour les utilisateurs non-privilégiés. Dynamique de données de masquage permet d'empêcher tout accès non autorisé à des données sensibles, en permettant aux clients de désigner la façon dont beaucoup de la nature sensible des données pour révéler avec un minimum d'impact sur la couche d'application. C'est une protection des données qui cache les données sensibles dans le jeu de résultats d'une requête de certains champs de base de données, alors que les données dans la base de données n'est pas modifié. Dynamique masquage des données est facile à utiliser avec les applications existantes, depuis le masquage règles sont appliquées dans les résultats de la requête. De nombreuses applications peuvent masquer les données sensibles sans modifier les requêtes existantes.
```
CREATE TABLE #tab(ID INT IDENTITY(1,1), column1 VARCHAR(12));

INSERT INTO #tab(column1)
VALUES('384844033434'),('743423547878'),('111224678885');

SELECT * FROM #tab;
```
De sortie:
```
╔════╦══════════════╗
║ ID ║   column1    ║
╠════╬══════════════╣
║  1 ║ 384844033434 ║
║  2 ║ 743423547878 ║
║  3 ║ 111224678885 ║
╚════╩══════════════╝

ALTER TABLE #tab
ALTER COLUMN column1 VARCHAR(12) MASKED WITH (FUNCTION = 'partial(3,"xxxxxx",3)');

SELECT * FROM #tab;
```
De sortie:
```
╔════╦══════════════╗
║ ID ║   column1    ║
╠════╬══════════════╣
║  1 ║ 384xxxxxx434 ║
║  2 ║ 743xxxxxx878 ║
║  3 ║ 111xxxxxx885 ║
╚════╩══════════════╝
```
LiveDemo

OriginalL'auteur Lukasz Szozda
1

Une simple requête select serait de retour juste ce qu'il est sur la table, peu importe si c'est crypté ou non.

Donc, je pense que vous ne pouvez pas faire cela sur la base de données.

Pour votre condition, vous avez besoin d'une bidirectionnel algorithme de chiffrement à utiliser dans votre application, de sorte que vous pouvez crypter les données avant de les enregistrer chiffré sur la base de données, et d'obtenir les informations chiffrées de la base de données et de les décrypter sur votre applicaition.

OriginalL'auteur Nathan
1

très simple bro
```
SELECT CONCAT (SUBSTR('Your string',1,3),LPAD(SUBSTR('Your string',-3),LENGTH('Your string')-1,'*')) RESULT FROM dual
```
de sortie :

Vous*******ing

si c'est num type de convertir char

Est-ce Oracle SQL ? Auteur de demande pour le T-SQL solution.

OriginalL'auteur Srinivas

Si vous souhaitez masquer le champ dont vous ne connaissez rien de longueur du champ. Vous pouvez mettre à niveau bluefeet code comme ceci:

ALTER FUNCTION MixUpCharacters
(
@OrigVal varchar(MAX)
)
RETURNS varchar(MAX)
AS
BEGIN
DECLARE @NewVal NVARCHAR(MAX)
DECLARE @OrigLen INT
DECLARE @LoopCt INT
DECLARE @Part NVARCHAR(MAX) = ''
DECLARE @PartLength INT     -- MastLength
DECLARE @PartStartIndex INT -- MaskStartIndex
SET @NewVal = ''
SET @LoopCt = 1
SET @OrigLen = LEN(@OrigVal)
IF(@OrigLen = 1)
BEGIN
RETURN 'X'
END
IF(@OrigLen < 6)
BEGIN
SET @PartStartIndex = @OrigLen / 2
SET @PartLength = @OrigLen - @PartStartIndex
SET @Part = SUBSTRING(@OrigVal, @PartStartIndex,  @PartLength)
END
ELSE IF(@OrigLen < 8)
BEGIN
SET @PartStartIndex = 3
SET @PartLength = @OrigLen - @PartStartIndex - 1
SET @Part = SUBSTRING(@OrigVal, @PartStartIndex,  @PartLength)
END
ELSE
BEGIN
SET @PartStartIndex = 4
SET @PartLength = @OrigLen - @PartStartIndex - 2
SET @Part = SUBSTRING(@OrigVal, @PartStartIndex,  @PartLength)
END
WHILE @LoopCt <= @PartLength
BEGIN
-- Current length of possible characters
SET @NewVal = @NewVal + 'X'
-- Advance the loop
SET @LoopCt = @LoopCt + 1
END
RETURN REPLACE(@OrigVal, @Part, @NewVal)
END

Vous pouvez tester comme ceci:

SELECT dbo.MixUpCharacters('1')
UNION ALL
SELECT dbo.MixUpCharacters('12')
UNION ALL
SELECT dbo.MixUpCharacters('123')
UNION ALL
SELECT dbo.MixUpCharacters('1234')
UNION ALL
SELECT dbo.MixUpCharacters('12345')
UNION ALL
SELECT dbo.MixUpCharacters('123456')
UNION ALL
SELECT dbo.MixUpCharacters('1234567')
UNION ALL
SELECT dbo.MixUpCharacters('12345678')
UNION ALL
SELECT dbo.MixUpCharacters('123456789')
UNION ALL
select dbo.MixUpCharacters('1234567890')
UNION ALL
select dbo.MixUpCharacters('12345678910')

RÉSULTATS:

X
X2
XX3
1XX4
1XXX5
12XX56
12XXX67
123XX678
123XXX789
123XXXX890
123XXXXX910

OriginalL'auteur Can OTUR

Vous devez vous connecter pour publier un commentaire.